Memory-based distributed processor architecture

ABSTRACT

Distributed processors and methods for compiling code for execution by distributed processors are disclosed. In one implementation, a distributed processor may include a substrate; a memory array disposed on the substrate; and a processing array disposed on the substrate. The memory array may include a plurality of discrete memory banks, and the processing array may include a plurality of processor subunits, each one of the processor subunits being associated with a corresponding, dedicated one of the plurality of discrete memory banks. The distributed processor may further include a first plurality of buses, each connecting one of the plurality of processor subunits to its corresponding, dedicated memory bank, and a second plurality of buses, each connecting one of the plurality of processor subunits to another of the plurality of processor subunits.

CROSS REFERENCES TO RELATED APPLICATIONS

This application is a continuation of PCT/IB2018/000995, filed on Jul.30, 2018, which claims the benefit of priority of U.S. ProvisionalPatent Application No. 62/538,722, filed on Jul. 30, 2017, U.S.Provisional Patent Application No. 62/538,724, filed on Jul. 30, 2017,and U.S. Provisional Patent Application No. 62/548,990, filed on Aug.23, 2017. All of the foregoing applications are incorporated herein byreference in their entireties.

BACKGROUND Technical Field

The present disclosure relates generally to apparatuses for facilitatingmemory-intensive operations. In particular, the present disclosurerelates to hardware chips that include processing elements coupled todedicated memory banks.

Background Information

As processor speeds and memory sizes both continue to increase, asignificant limitation on effective processing speeds is the von Neumannbottleneck. The von Neumann bottleneck results from throughputlimitations resulting from conventional computer architecture. Inparticular, data transfer from memory to the processor is oftenbottlenecked compared to actual computations undertaken by theprocessor. Accordingly, the number of clock cycles to read and writefrom memory increases significantly with memory-intensive processes.These clock cycles result in lower effective processing speeds becausereading and writing from memory consumes clock cycles that cannot beused for performing operations on data. Moreover, the computationalbandwidth of the processor is generally larger than the bandwidth of thebuses that the processor uses to access the memory.

These bottlenecks are particularly pronounced for memory-intensiveprocesses, such as neural network and other machine learning algorithms;database construction, indexing searching, and querying; and other tasksthat include more reading and writing operation than data processingoperations.

Additionally, the rapid growth in volume and granularity of availabledigital data has created opportunities to develop machine learningalgorithms and has enabled new technologies. However, it has alsobrought cumbersome challenges to the world of data bases and parallelcomputing. For example, the rise of social media and the Internet ofThings (IoT) creates digital data at a record rate. This new data can beused to create algorithms for a variety of purposes, ranging from newadvertising techniques to more precise control methods of industrialprocesses. However, the new data has been difficult to store, process,analyze and handle.

New data resources can be massive, sometimes in the order of peta- tozettabytes. Moreover, the growth rate of these data resources may exceeddata processing capabilities. Therefore, data scientists have turned toparallel data processing techniques, to tackle these challenges. In aneffort to increase computation power and handle the massive amount ofdata, scientists have attempted to create systems and methods capable ofparallel intensive computing. But these existing systems and methodshave not kept up with the data processing requirements, often becausethe techniques employed are limited by their demand of additionalresources for data management, integration of segregated data, andanalysis of the sectioned data.

To facilitate the manipulation of large data sets, engineers andscientists now seek to improve the hardware used to analyze data. Forexample, new semiconductor processors or chips (such as those describedherein) may be designed specifically for data intensive tasks byincorporating memory and processing functions in a single substratefabricated in technologies more fitting for memory operations ratherthan arithmetic computation. With integrated circuits specificallydesigned for data-intensive tasks, it is possible to meet the new dataprocessing requirements. Nonetheless, this new approach to tackle dataprocessing of large data sets requires solving new issues in chip designand fabrication. For instance, if the new chips designed for dataintensive tasks are manufactured with fabrication techniques andarchitectures used for common chips, they would have a poor performanceand/or unacceptable yields. In addition, if the new chips are designedto operate with current data handling methods, they will have poorperformance because current methods can limit the chip's ability tohandle parallel operations.

The present disclosure describes solutions for mitigating or overcomingone or more of the problems set forth above, among other problems in theprior art.

SUMMARY

Embodiments consistent with the present disclosure provide apparatusesincluding hardware processing chips. The disclosed embodiments may usededicated memory banks paired with processing elements to provide moreefficient effective processing speeds than conventional processors. Forexample, consistent with the disclosed embodiments, the disclosed chipsmay include dedicated buses between each processing element and itscorresponding memory banks. In addition, the disclosed chips may be freeof arbiters and/or other hardware that controls timing of data transfersbetween the processing elements. Other disclosed non-transitorycomputer-readable media may store instructions for compilinghigher-level instructions to lower-level instructions executed byhardware chips disclosed herein.

Some embodiments of the present disclosure include a distributedprocessor, comprising: a substrate; a memory array disposed on thesubstrate, the memory array including a plurality of discrete memorybanks; a processing array disposed on the substrate, the processingarray including a plurality of processor subunits, each one of theprocessor subunits being associated with a corresponding, dedicated oneof the plurality of discrete memory banks; a first plurality of buses,each connecting one of the plurality of processor subunits to itscorresponding, dedicated memory bank; and a second plurality of buses,each connecting one of the plurality of processor subunits to another ofthe plurality of processor subunits.

Other embodiments consistent with the present disclosure include amemory chip, comprising: a substrate; a memory array disposed on thesubstrate, the memory array including a plurality of discrete memorybanks; a processing array disposed on the substrate, the processingarray including a plurality of address generators, each one of theaddress generators being associated with a corresponding, dedicated oneof the plurality of discrete memory banks; and a plurality of buses,each connecting one of the plurality of address generators to itscorresponding, dedicated memory bank.

Another embodiment consistent with the present disclosure may include adistributed processor, comprising: a substrate; a memory array disposedon the substrate, the memory array including a plurality of discretememory banks, wherein each of the discrete memory banks has a capacitygreater than one megabyte; and a processing array disposed on thesubstrate, the processing array including a plurality of processorsubunits, each one of the processor subunits being associated with acorresponding, dedicated one of the plurality of discrete memory banks.

Still other embodiments consistent with the present disclosure mayinclude a distributed processor, comprising: a substrate; a memory arraydisposed on the substrate, the memory array including a plurality ofdiscrete memory banks; and a processing array disposed on the substrate,the processing array including a plurality of processor subunits, eachone of the processor subunits being associated with a corresponding,dedicated one of the plurality of discrete memory banks; and a pluralityof buses, each one of the plurality of buses connecting one of theplurality of processor subunits to at least another one of the pluralityof processor subunits, wherein the plurality of buses are free of timinghardware logic components such that data transfers between processorsubunits and across corresponding ones of the plurality of buses areuncontrolled by timing hardware logic components.

Other embodiments may include a distributed processor on a memory chip,comprising: a substrate; a memory array disposed on the substrate, thememory array including a plurality of discrete memory banks; and aprocessing array disposed on the substrate, the processing arrayincluding a plurality of processor subunits, each one of the processorsubunits being associated with a corresponding, dedicated one of theplurality of discrete memory banks; and a plurality of buses, each oneof the plurality of buses connecting one of the plurality of processorsubunits to a corresponding, dedicated one of the plurality of discretememory banks, wherein the plurality of buses are free of timing hardwarelogic components such that data transfers between a processor subunitand a corresponding, dedicated one of the plurality of discrete memorybanks and across a corresponding one of the plurality of buses areuncontrolled by timing hardware logic components.

Other embodiments may include a distributed processor, comprising: asubstrate; a memory array disposed on the substrate, the memory arrayincluding a plurality of discrete memory banks; and a processing arraydisposed on the substrate, the processing array including a plurality ofprocessor subunits, each one of the processor subunits being associatedwith a corresponding, dedicated one of the plurality of discrete memorybanks; and a plurality of buses, each one of the plurality of busesconnecting one of the plurality of processor subunits to at leastanother one of the plurality of processor subunits, wherein theplurality of processor subunits are configured to execute software thatcontrols timing of data transfers across the plurality of buses to avoidcolliding data transfers on at least one of the plurality of buses.

Other embodiments may include a distributed processor on a memory chip,comprising: a substrate; a plurality of processor subunits disposed onthe substrate, each processor subunit being configured to execute aseries of instructions independent from other processor subunits, eachseries of instructions defining a series of tasks to be performed by asingle processor subunit; a corresponding plurality of memory banksdisposed on the substrate, each one of the plurality processor subunitsbeing connected to at least one dedicated memory bank not shared by anyothers of the plurality of processor subunits; and a plurality of buses,each of the plurality of buses connecting one of the plurality ofprocessor subunits to at least one other of the plurality of processorsubunits, wherein data transfers across at least one of the plurality ofbuses are predefined by the series of instructions included in aprocessor subunit connected to the at least one of the plurality ofbuses.

Other embodiments may include a distributed processor on a memory chip,comprising: a plurality of processor subunits disposed on the memorychip; a plurality of memory banks disposed on the memory chip, whereineach one of the plurality of memory banks is configured to store dataindependent from data stored in other ones of the plurality of memorybanks, and wherein each one of the plurality of processor subunits isconnected to at least one dedicated memory bank from among the pluralityof memory banks; and a plurality of buses, wherein each one of theplurality of buses connects one of the plurality of processor subunitsto one or more corresponding, dedicated memory banks from among theplurality of memory banks, wherein data transfers across a particularone of the plurality of buses are controlled by a correspondingprocessor subunit connected to the particular one of the plurality ofbuses.

Other embodiments may include a distributed processor on a memory chip,comprising: a plurality of processor subunits disposed on the memorychip; a plurality of memory banks disposed on the memory chip, whereineach one of the plurality of processor subunits is connected to at leastone dedicated memory bank from among the plurality of memory banks, andwherein each memory bank of the plurality of memory banks is configuredto store data independent from data stored in other ones of theplurality of memory banks, and wherein at least some of the data storedin one particular memory bank from among the plurality of memory bankscomprises a duplicate of data stored in at least another one of theplurality of memory banks; and a plurality of buses, wherein each one ofthe plurality of buses connects one of the plurality of processorsubunits to one or more corresponding, dedicated memory banks from amongthe plurality of memory banks, wherein data transfers across aparticular one of the plurality of buses are controlled by acorresponding processor subunit connected to the particular one of theplurality of buses.

Other embodiments may include a distributed processor on a memory chip,comprising: a plurality of processor subunits disposed on the memorychip; a plurality of memory banks disposed on the memory chip, whereineach one of the plurality of processor subunits is connected to at leastone dedicated memory bank from among the plurality of memory banks, andwherein each memory bank of the plurality of memory banks is configuredto store data independent from data stored in other ones of theplurality of memory banks, and wherein at least some of the data storedin one particular memory bank from among the plurality of memory bankscomprises a duplicate of data stored in at least another one of theplurality of memory banks; and a plurality of buses, wherein each one ofthe plurality of buses connects one of the plurality of processorsubunits to one or more corresponding, dedicated memory banks from amongthe plurality of memory banks, wherein data transfers across aparticular one of the plurality of buses are controlled by acorresponding processor subunit connected to the particular one of theplurality of buses.

Other embodiments may include a non-transitory computer-readable mediumstoring instructions for compiling a series of instructions forexecution on a memory chip comprising a plurality of processor subunitsand a plurality of memory banks, wherein each processor subunit fromamong the plurality of processor subunits is connected to at least onecorresponding, dedicated memory bank from among the plurality of memorybanks, the instructions causing at least one processor to: divide theseries of instructions into a plurality of groups of sub-seriesinstructions, the division comprising: assigning tasks associated withthe series of instructions to different ones of the processor subunits,wherein the processor subunits are spatially distributed among theplurality of memory banks disposed on the memory chip; generating tasksto transfer data between pairs of the processor subunits of the memorychip, each pair of processor subunits being connected by a bus, andgrouping the assigned and generated tasks into the plurality of groupsof sub-series instructions, wherein each of the plurality of groups ofsub-series instructions corresponds to a different one of the pluralityof processor sub-units; generate machine code corresponding to each ofthe plurality of groups of subs-series instructions; and assign thegenerated machine code corresponding to each of the plurality of groupsof subs-series instructions to a corresponding one of the plurality ofprocessor subunits in accordance with the division.

Other embodiments may include a memory chip, comprising: a plurality ofmemory banks, each memory bank having a bank row decoder, a bank columndecoder, and a plurality of memory sub-banks, each memory sub-bankhaving a sub-bank row decoder and a sub-bank column decoder for allowingreads and writes to locations on the memory sub-bank, each memorysub-bank comprising: a plurality of memory mats, each memory mat havinga plurality of memory cells, wherein the sub-bank row decoders and thesub-bank column decoders are connected to the bank row decoder and thebank column decoder.

Other embodiments may include a memory chip, comprising: a plurality ofmemory banks, each memory bank having a bank controller and a pluralityof memory sub-banks, each memory sub-bank having a sub-bank row decoderand a sub-bank column decoder for allowing reads and writes to locationson the memory sub-bank, each memory sub-bank comprising: a plurality ofmemory mats, each memory mat having a plurality of memory cells, whereinthe sub-bank row decoders and the sub-bank column decoders process readand write requests from the bank controller.

Other embodiments may include a memory chip, comprising: a plurality ofmemory banks, each memory bank having a having a bank controller forprocessing reads and writes to locations on the memory bank, each memorybank comprising: a plurality of memory mats, each memory mat having aplurality of memory cells and having a mat row decoder and a mat columndecoder, wherein the mat row decoders and the mat column decodersprocess read and write requests from the sub-bank controller.

Other embodiments may include a memory chip, comprising: a plurality ofmemory banks, each memory bank having a bank controller, a row decoder,and a column decoder for allowing reads and writes to locations on thememory bank; and a plurality of buses connecting each controller of theplurality of bank controllers to at least one other controller of theplurality of bank controllers.

One aspect of the present disclosure is directed to a memory deviceincluding a substrate; a plurality of memory banks on the substrate; aplurality of primary logic blocks on the substrate, each of theplurality of primary logic blocks being connected to at least one of theplurality of memory banks; a plurality of redundant blocks on thesubstrate, each of the plurality of redundant blocks being connected toat least one of the memory banks, each of the plurality of redundantblocks replicating at least one of the plurality of primary logicblocks; and a plurality of configuration switches on the substrate, eachone of the plurality of the configuration switches being connected to atleast one of the plurality of primary logic blocks or to at least one ofthe plurality of redundant blocks. In the memory device, upon detectionof a fault associated with one of the plurality of primary logic blocks:a first configuration switch of the plurality of configuration switchesmay be configured to disable the one of the plurality of primary logicblocks, and a second configuration switch of the plurality ofconfiguration switches may be configured to enable one of the pluralityof redundant blocks that replicates the one of the plurality of primarylogic blocks.

Another aspect of the present disclosure is directed to a distributedprocessor on a memory chip including a substrate; an address manager onthe substrate; a plurality of primary logic blocks on the substrate,each of the plurality of primary logic blocks being connected to atleast one of the plurality of memory banks; a plurality of redundantblocks on the substrate, each of the plurality of redundant blocks beingconnected to at least one of the plurality of memory banks, each of theplurality of redundant blocks replicating at least one of the pluralityof primary logic blocks; and a bus on the substrate connected to each ofthe plurality of primary logic blocks, each of the plurality ofredundant blocks, and the address manager. In the processor may assignrunning ID numbers to blocks in the plurality of primary logic blocksthat pass a testing protocol; assign illegal ID numbers to blocks in theplurality of primary logic blocks that do not pass the testing protocol;and assign running ID numbers to blocks in the plurality of redundantblocks that pass the testing protocol.

Yet another aspect of the present disclosure is directed to a method forconfiguring a distributed processor on a memory chip. The method mayinclude: testing each one of a plurality of primary logic blocks on thesubstrate of the memory chip for at least one circuit functionality;identifying at least one faulty logic block in the plurality of primarylogic blocks based on the testing results, the at least one faulty logicblock being connected to at least one memory bank disposed on thesubstrate of the memory chip; testing at least one redundant block onthe substrate of the memory chip for the at least one circuitfunctionality, the at least one redundant block replicating the at leastone faulty logic block and being connected to the at least one memorybank; disabling the at least one faulty logic block by applying anexternal signal to a deactivation switch, the deactivation switch beingconnected with the at least one faulty logic block and being disposed onthe substrate of the memory chip; and enabling the at least oneredundant block by applying the external signal to an activation switch,the activation switch being connected with the at least one redundantblock and being disposed on the substrate of the memory chip.

Another aspect of the present disclosure is directed to a method forconfiguring a distributed processor on a memory chip. The method mayinclude enabling a plurality of primary logic blocks and a plurality ofredundant blocks on the substrate of the memory; testing each one of theplurality of primary logic blocks on the substrate of the memory chipfor at least one circuit functionality; identifying at least one faultylogic block in the plurality of primary logic blocks based on thetesting results, the at least one faulty logic block being connected toat least one memory bank disposed on the substrate of the memory chip;testing at least one redundant block on the substrate of the memory chipfor the at least one circuit functionality, the at least one redundantblock replicating the at least one faulty logic block and beingconnected to the at least one memory bank; and disabling at least oneredundant block by applying the external signal to an activation switch,the activation switch being connected with the at least one redundantblock and being disposed on the substrate of the memory chip.

One aspect of the present disclosure is directed to a processing device.The processing device may include a substrate; a plurality of memorybanks on the substrate; a memory controller on the substrate connectedto each one of the plurality of memory banks; and a plurality ofprocessing units on the substrate, each one of the plurality ofprocessing units being connected to the memory controller, the pluralityof processing units including a configuration manager. In the processingdevice, the configuration manager is configured to receive a firstindication of a task to be performed, the task requiring at least onecomputation; signal at least one selected processing unit from theplurality of processing units based upon a capability of the selectedprocessing unit for performing the at least one computation; andtransmitting a second indication to the at least one selected processingunit, and the memory controller is configured to route data from atleast two memory banks to the at least one selected processing unitusing at least one communication line, the at least one communicationline being connected to the at least two memory banks and the at leastone selected processing unit via the memory controller.

Another aspect of the present disclosure is directed to a methodperformed for operating a distributed memory device. The method mayinclude: compiling, by a compiler, a task for the distributed memorydevice, the task requiring at least one computation, the compiling mayinclude determining a number of words that are required simultaneouslyto perform the task, and providing instructions for writing words thatneed to be accessed simultaneously in a plurality of memory banksdisposed on the substrate when a number a number of words that can beaccessed simultaneously from one of the plurality of memory banks islower than the number of words that are required simultaneously;receiving, by a configuration manager disposed on the substrate, anindication to perform the task; and in response to receiving theindication, configuring a memory controller disposed in the substrateto: within a first line access cycle: access at least one first wordfrom a first memory bank from the plurality of memory banks using afirst memory line, send the at least one first word to at least oneprocessing unit, and open a first memory line in the second memory bankto access a second address from the second memory bank from theplurality of memory banks, and within a second line access cycle: accessat least one second word from the second memory bank using the firstmemory line, send the at least one second word to at least oneprocessing unit, and access a third address from the first memory bankusing a second memory line in the first bank.

Yet another aspect of the present disclosure is directed to anon-transitory computer-readable medium that stores instructions that,when executed by at least one processor, cause the at least oneprocessor to determine a number of words that are requiredsimultaneously to perform a task, the task requiring at least onecomputation; write words that need to be accessed simultaneously in aplurality of memory banks disposed on the substrate when a number anumber of words that can be accessed simultaneously from one of theplurality of memory banks is lower than the number of words that arerequired simultaneously; transmit an indication to perform the task to aconfiguration manager disposed on the substrate; and transmitinstructions to configure a memory controller disposed on the substrateto, within a first line access cycle: access at least one first wordfrom a first memory bank from the plurality of memory banks using afirst memory line, send the at least one first word to at least oneprocessing unit, and open a first memory line in the second memory bankto access a second address from the second memory bank from theplurality of memory banks, and within a second line access cycle: accessat least one second word from the second memory bank using the firstmemory line, send the at least one second word to at least oneprocessing unit, and access a third address from the first memory bankusing a second memory line in the first bank.

Consistent with other disclosed embodiments, non-transitorycomputer-readable storage media may store program instructions, whichare executed by at least one processing device and perform any of themethods described herein.

The foregoing general description and the following detailed descriptionare exemplary and explanatory only and are not restrictive of theclaims.

BRIEF DESCRIPTION OF THE DRAWINGS

The accompanying drawings, which are incorporated in and constitute apart of this disclosure, illustrate various disclosed embodiments. Inthe drawings:

FIG. 1 is a diagrammatic representation of a central processing unit(CPU).

FIG. 2 is a diagrammatic representation of a graphics processing unit(GPU).

FIG. 3A is a diagrammatic representation of an embodiment of anexemplary hardware chip consistent with the disclosed embodiments.

FIG. 3B is a diagrammatic representation of another embodiment of anexemplary hardware chip consistent with the disclosed embodiments.

FIG. 4 is a diagrammatic representation of a generic command executed byan exemplary hardware chip consistent with the disclosed embodiments.

FIG. 5 is a diagrammatic representation of a specialized commandexecuted by an exemplary hardware chip consistent with the disclosedembodiments.

FIG. 6 is a diagrammatic representation of a processing group for use inan exemplary hardware chip consistent with the disclosed embodiments.

FIG. 7A is a diagrammatic representation of a rectangular array ofprocessing groups consistent with the disclosed embodiments.

FIG. 7B is a diagrammatic representation of an elliptical array ofprocessing groups consistent with the disclosed embodiments.

FIG. 7C is a diagrammatic representation an array of hardware chipsconsistent with the disclosed embodiments.

FIG. 7D is a diagrammatic representation another array of hardware chipsconsistent with the disclosed embodiments.

FIG. 8 is a flowchart depicting an exemplary method for compiling aseries of instructions for execution on an exemplary hardware chipconsistent with the disclosed embodiments.

FIG. 9 is a diagrammatic representation of a memory bank.

FIG. 10 is a diagrammatic representation of a memory bank.

FIG. 11 is a diagrammatic representation of an embodiment of anexemplary memory bank with sub-bank controls consistent with thedisclosed embodiments.

FIG. 12 is a diagrammatic representation of another embodiment of anexemplary memory bank with sub-bank controls consistent with thedisclosed embodiments.

FIG. 13 is a block diagram of an exemplary memory chip, consistent withdisclosed embodiments.

FIG. 14 is a block diagram of an exemplary redundant logic block set,consistent with disclosed embodiments.

FIG. 15 is a block diagram for an exemplary logic block, consistent withdisclosed embodiments.

FIG. 16 are block diagrams of exemplary logic blocks connected with abus, consistent with disclosed embodiments.

FIG. 17 is a block diagram for exemplary logic blocks connected inseries, consistent with disclosed embodiments.

FIG. 18 is a block diagram of exemplary logic blocks connected in atwo-dimension array, consistent with disclosed embodiments.

FIG. 19 is a block diagram for exemplary logic blocks in a complexconnection, consistent with disclosed embodiments.

FIG. 20 is an exemplary flow chart illustrating a redundant blockenabling process, consistent with disclosed embodiments.

FIG. 21 is an exemplary flow chart illustrating an address assignmentprocess, consistent with disclosed embodiments.

FIG. 22 provides block diagrams for exemplary processing devices,consistent with disclosed embodiments.

FIG. 23 is a block diagram of an exemplary processing device, consistentwith disclosed embodiments.

FIG. 24 includes exemplary memory configuration diagrams, consistentwith disclosed embodiments.

FIG. 25 is an exemplary flowchart illustrating a memory configurationprocess, consistent with disclosed embodiments.

FIG. 26 is an exemplary flowchart illustrating a memory read process,consistent with disclosed embodiments.

FIG. 27 is an exemplary flowchart illustrating a process execution,consistent with disclosed embodiments.

DETAILED DESCRIPTION

The following detailed description refers to the accompanying drawings.Wherever convenient, the same reference numbers are used in the drawingsand the following description to refer to the same or similar parts.While several illustrative embodiments are described herein,modifications, adaptations and other implementations are possible. Forexample, substitutions, additions or modifications may be made to thecomponents illustrated in the drawings, and the illustrative methodsdescribed herein may be modified by substituting, reordering, removing,or adding steps to the disclosed methods. Accordingly, the followingdetailed description is not limited to the disclosed embodiments andexamples. Instead, the proper scope is defined by the appended claims.

Processor Architecture

As used throughout this disclosure, the term “hardware chip” refers to asemiconductor wafer (such as silicon or the like) on which one or morecircuit elements (such as transistors, capacitors, resistors, and/or thelike) are formed. The circuit elements may form processing elements ormemory elements. A “processing element” refers to one or more circuitelements that, together, perform at least one logic function (such as anarithmetic function, a logic gate, other Boolean operations, or thelike). A processing element may be a general-purpose processing element(such as a configurable plurality of transistors) or a special-purposeprocessing element (such as a particular logic gate or a plurality ofcircuit elements designed to perform a particular logic function). A“memory element” refers to one or more circuit elements that can be usedto store data. A “memory element” may also be referred to as a “memorycell.” A memory element may be dynamic (such that electrical refreshesare required to maintain the data store), static (such that datapersists for at least some time after power loss), or non-volatilememories.

Processing elements may be joined to form processor subunits. A“processor subunit” may thus comprise a smallest grouping of processingelements that may execute at least one task or instructions (e.g., of aprocessor instruction set). For example, a subunit may comprise one ormore general-purpose processing elements configured to executeinstructions together, one or more general-purpose processing elementspaired with one or more special-purpose processing elements configuredto execute instructions in a complementary fashion, or the like. Theprocessor subunits may be arranged on a substrate (e.g., a wafer) in anarray. Although the “array” may comprise a rectangular shape, anyarrangement of the subunits in the array may be formed on the substrate.

Memory elements may be joined to form memory banks. For example, amemory bank may comprise one or more lines of memory elements linkedalong at least one wire (or other conductive connection). Furthermore,the memory elements may be linked along at least one addition wire inanother direction. For example, the memory elements may be arrangedalong wordlines and bitlines, as explained below. Although the memorybank may comprise lines, any arrangement of the elements in the bank maybe used to form the bank on the substrate. Moreover, one or more banksmay be electrically joined to at least one memory controller to form amemory array. Although the memory array may comprise a rectangulararrangement of the banks, any arrangement of the banks in the array maybe formed on the substrate.

As further used throughout this disclose, a “bus” refers to anycommunicative connection between elements of a substrate. For example, awire or a line (forming an electrical connection), an optical fiber(forming an optical connection), or any other connection conductingcommunications between components may be referred to as a “bus.”

Conventional processors pair general-purpose logic circuits with sharedmemories. The shared memories may store both instruction sets forexecution by the logic circuits as well as data used for and resultingfrom execution of the instruction sets. As described below, someconventional processors use a caching system to reduce delays inperforming pulls from the shared memory; however, conventional cachingsystems remain shared. Conventional processors include centralprocessing units (CPUs), graphics processing units (GPUs), variousapplication-specific integrated circuits (ASICs), or the like. FIG. 1shows an example of a CPU, and FIG. 2 shows an example of a GPU.

As shown in FIG. 1, a CPU 100 may comprise a processing unit 110 thatincludes one or more processor subunits, such as processor subunit 120 aand processor subunit 120 b. Although not depicted in FIG. 1, eachprocessor subunit may comprise a plurality of processing elements.Moreover, the processing unit 110 may include one or more levels ofon-chip cache. Such cache elements are generally formed on the samesemiconductor die as processing unit 110 rather than being connected toprocessor subunits 120 a and 120 b via one or more buses formed in thesubstrate containing processor subunits 120 a and 120 b and the cacheelements. An arrangement directly on the same die, rather than beingconnected via buses, is common for both first-level (L1) andsecond-level (L2) caches in conventional processors. Alternatively, inolder processors, L2 caches were shared amongst processor subunits usingback-side buses between the subunits and the L2 caches. Back-side busesare generally larger than front-side buses, described below.Accordingly, because cache is to be shared with all processor subunitson the die, cache 130 may be formed on the same die as processorsubunits 120 a and 120 b or communicatively coupled to processorsubunits 120 a and 120 b via one or more back-side buses. In bothembodiments without buses (e.g., cache is formed directly on-die) aswell as embodiments using back-side buses, the caches are shared betweenprocessor subunits of the CPU.

Moreover, processing unit 110 communicates with shared memory 140 a andmemory 140 b. For example, memories 140 a and 140 b may represent memorybanks of shared dynamic random access memory (DRAM). Although depictedwith two banks, most conventional memory chips include between eight andsixteen memory banks. Accordingly, processor subunits 120 a and 120 bmay use shared memories 140 a and 140 b to store data that is thenoperated upon by processor subunits 120 a and 120 b. This arrangement,however, results in the buses between memories 140 a and 140 b andprocessing unit 110 acting as a bottleneck when the clock speeds ofprocessing unit 110 exceed data transfer speeds of the buses. This isgenerally true for conventional processors, resulting in lower effectiveprocessing speeds than the stated processing speeds based on clock rateand number of transistors.

As shown in FIG. 2, similar deficiencies persist in GPUs. A GPU 200 maycomprise a processing unit 210 that includes one or more processorsubunits (e.g., subunits 220 a, 220 b, 220 c, 220 d, 220 e, 220 f, 220g, 220 h, 220 i, 220 j, 220 k, 220 l, 220 m, 220 n, 220 o, and 220 p).Moreover, the processing unit 210 may include one or more levels ofon-chip cache and/or register files. Such cache elements are generallyformed on the same semiconductor die as processing unit 210. Indeed, inthe example of FIG. 2, cache 210 is formed on the same die as processingunit 210 and shared amongst all of the processor subunits, while caches230 a, 230 b, 230 c, and 230 d are formed on a subset of the processorsubunits, respectively, and dedicated thereto.

Moreover, processing unit 210 communicates with shared memories 250 a,250 b, 250 c, and 250 d. For example, memories 250 a, 250 b, 250 c, and250 d may represent memory banks of shared DRAM. Accordingly, theprocessor subunits of processing unit 210 may use shared memories 250 a,250 b, 250 c, and 250 d to store data that is then operated upon by theprocessor subunits. This arrangement, however, results in the busesbetween memories 250 a, 250 b, 250 c, and 250 d and processing unit 210acting as a bottleneck, similar to the bottleneck described above forCPUs.

Overview of Disclosed Hardware Chips

FIG. 3A is a diagrammatic representation of an embodiment depicting anexemplary hardware chip 300. Hardware chip 300 may comprise adistributed processor designed to mitigate the bottlenecks describedabove for CPUs, GPUs, and other conventional processors. A distributedprocessor may include a plurality of processor subunits distributedspatially on a single substrate. Moreover, as explained above, indistributed processors of the present disclosure, corresponding memorybanks are also spatially distributed on the substrate. In someembodiments, a distributed processor may be associated with a set ofinstructions, and each one of the processor subunits of the distributedprocessor may be responsible for performing one or more tasks includedin the set of instructions.

As depicted in FIG. 3A, hardware chip 300 may comprise a plurality ofprocessor subunits, e.g., logic and control subunits 320 a, 320 b, 320c, 320 d, 320 e, 320 f, 320 g, and 320 h. As further depicted in FIG.3A, each processor subunit may have a dedicated memory instance. Forexample, logic and control subunit 320 a is operably connected todedicated memory instance 330 a, logic and control subunit 320 b isoperably connected to dedicated memory instance 330 b, logic and controlsubunit 320 c is operably connected to dedicated memory instance 330 c,logic and control subunit 320 d is operably connected to dedicatedmemory instance 330 d, logic and control subunit 320 e is operablyconnected to dedicated memory instance 330 e, logic and control subunit320 f is operably connected to dedicated memory instance 330 f, logicand control subunit 320 g is operably connected to dedicated memoryinstance 330 g, and logic and control subunit 320 h is operablyconnected to dedicated memory instance 330 h.

Although FIG. 3A depicts each memory instance as a single memory bank,hardware chip 300 may include two or more memory banks as a dedicatedmemory instance for a processor subunit on hardware chip 300.Furthermore, although FIG. 3A depicts each processor subunit ascomprising both a logic component and a control for the dedicated memorybank(s), hardware chip 300 may use controls for the memory banks thatare separate, at least in part, from the logic components. Moreover, asdepicted in FIG. 3A, two or more processor subunits and theircorresponding memory banks may be grouped, e.g., into processing groups310 a, 310 b, 310 c, and 310 d. A “processing group” may represent aspatial distinction on a substrate on which hardware chip 300 is formed.Accordingly, a processing group may include further controls for thememory banks in the group, e.g., controls 340 a, 340 b, 340 c, and 340d. Additionally or alternatively, a “processing group” may represent alogical grouping for the purposes of compiling code for execution onhardware chip 300. Accordingly, a compiler for hardware chip 300(further described below) may divide an overall set of instructionsbetween the processing groups on hardware chip 300.

Furthermore, host 350 may provide instructions, data, and other input tohardware chip 300 and read output from the same. Accordingly, a set ofinstructions may be executed entirely on a single die, e.g., the diehosting hardware chip 300. Indeed, the only communications off-die mayinclude the loading of instructions to hardware chip 300, any input sentto hardware chip 300, and any output read from hardware chip 300.Accordingly, all calculations and memory operations may be performedon-die (on hardware chip 300) because the processor subunits of hardwarechip 300 communicate with dedicated memory banks of hardware chip 300.

FIG. 3B is a diagrammatic representation of an embodiment depictinganother exemplary hardware chip 300′. Although depicted as analternative to hardware chip 300, the architecture depicted in FIG. 3Bmay be combined, at least in part, with the architecture depicted inFIG. 3A.

As depicted in FIG. 3B, hardware chip 300′ may comprise a plurality ofprocessor subunits, e.g., processor subunits 350 a, 350 b, 350 c, and350 d. As further depicted in FIG. 3B, each processor subunit may have aplurality of dedicated memory instances. For example, processor subunit350 a is operably connected to dedicated memory instances 330 a and 330b, processor subunit 350 b is operably connected to dedicated memoryinstances 330 c and 330 d, processor subunit 350 c is operably connectedto dedicated memory instances 330 e and 330 f, and processor subunit 350d is operably connected to dedicated memory instances 330 g and 330 h.Moreover, as depicted in FIG. 3B, the processor subunits and theircorresponding memory banks may be grouped, e.g., into processing groups310 a, 310 b, 310 c, and 310 d. As explained above, a “processing group”may represent a spatial distinction on a substrate on which hardwarechip 300′ is formed and/or a logical grouping for the purposes ofcompiling code for execution on hardware chip 300′.

As further depicted in FIG. 3B, the processor subunits may communicatewith each other via buses. For example, as shown in FIG. 3B, processorsubunit 350 a may communicate with processor subunit 350 b via bus 360a, with processor subunit 350 c via bus 360 c, and with processorsubunit 350 d via bus 360 f. Similarly, processor subunit 350 b maycommunicate with processor subunit 350 a via bus 360 a (as describedabove), with processor subunit 350 c via bus 360 e, and with processorsubunit 350 d via bus 360 d. In addition, processor subunit 350 c maycommunicate with processor subunit 350 a via bus 360 c (as describedabove), with processor subunit 350 b via bus 360 e (as described above),and with processor subunit 350 d via bus 360 b. Accordingly, processorsubunit 350 d may communicate with processor subunit 350 a via bus 360 f(as described above), with processor subunit 350 b via bus 360 d (asdescribed above), and with processor subunit 350 c via bus 360 b (asdescribed above). One of ordinary skill will understand that fewer busesthan depicted in FIG. 3B may be used. For example, bus 360 e may beeliminated such that communications between processor subunit 350 b and350 c pass through processor subunit 350 a and/or 350 d. Similarly, bus360 f may be eliminated such that communications between processorsubunit 350 a and processor subunit 350 d pass through processor subunit350 b or 350 c.

Moreover, one of ordinary skill will understand that architectures otherthan those depicted in FIGS. 3A and 3B may be used. For example, anarray of processing groups, each with a single processor subunit andmemory instance, may be arranged on a substrate. Processor subunits mayadditionally or alternatively form part of controllers for correspondingdedicated memory banks, part of controllers for memory mats ofcorresponding dedicated memory, or the like.

In view of the architecture described above, hardware chips 300 and 300′may provide significant increases in efficiency for memory-intensivetasks as compared with traditional architectures. For example, databaseoperations and artificial intelligence algorithms (such as neuralnetworks) are examples of memory-intensive tasks for which traditionalarchitectures are less efficient than hardware chips 300 and 300′.Accordingly, hardware chips 300 and 300′ may be referred to as databaseaccelerator processors and/or artificial intelligence acceleratorprocessors.

Configuring the Disclosed Hardware Chips

The hardware chip architecture described above may be configured forexecution of code. For example, each processor subunit may individuallyexecute code (defining a set of instructions) apart from other processorsubunits in the hardware chip. Accordingly, rather than relying on anoperating system to manage multithreading or using multitasking (whichis concurrency rather than parallelism), hardware chips of the presentdisclosure may allow for processor subunits to operate fully inparallel.

In addition to a fully parallel implementation described above, at leastsome of the instructions assigned to each processor subunit may beoverlapping. For example, a plurality of processor subunits on adistributed processor may execute overlapping instructions as, forexample, an implementation of an operating system or other managementsoftware, while executing non-overlapping instructions in order toperform parallel tasks within the context of the operating system orother management software.

FIG. 4 depicts an exemplary process 400 for executing a generic commandwith processing group 410. For example, processing group 410 maycomprise a portion of a hardware chip of the present disclosure, e.g.,hardware chip 300, hardware chip 300′, or the like.

As depicted in FIG. 4, a command may be sent to processor subunit 430,which is paired with dedicated memory instance 420. An external host(e.g., host 350) may send the command to processing group 410 forexecution. Alternatively, host 350 may have sent an instruction setincluding the command for storage in memory instance 420 such thatprocessor subunit 430 may retrieve the command from memory instance 420and execute the retrieved command. Accordingly, the command may beexecuted by processing element 440, which is a generic processingelement configurable to execute the received command. Moreover,processing group 410 may include a control 460 for memory instance 420.As depicted in FIG. 4, control 460 may perform any reads and/or writesto memory instance 420 required by processing element 440 when executingthe received command. After execution of the command, processing group410 may output the result of the command, e.g., to the external host orto a different processing group on the same hardware chip.

In some embodiments, as depicted in FIG. 4, processor subunit 430 mayfurther include an address generator 450. An “address generator” maycomprise a plurality of processing elements that are configured todetermine addresses in one or more memory banks for performing reads andwrites and may also perform operations on the data located at thedetermined addresses (e.g., addition, subtraction, multiplication, orthe like). For example, address generator 450 may determine addressesfor any reads or writes to memory. In one example, address generator 450may increase efficiency by overwriting a read value with a new valuedetermined based on the command when the read value is no longer needed.Additionally or alternatively, address generator 450 may selectavailable addresses for storage of results from execution of thecommand. This may allow for scheduling of result read-off for a laterclock cycle, when it is more convenient for the external host. Inanother example, address generator 450 may determine addresses to readfrom and write to during a multi-cycle calculation, such as a vector ormatrix multiply-accumulate calculation. Accordingly, address generator450 may maintain or calculate memory addresses for reading data andwriting intermediate results of the multi-cycle calculation such thatprocessor subunit 430 may continue processing without having to storethese memory addresses.

FIG. 5 depicts an exemplary process 500 for executing a specializedcommand with processing group 510. For example, processing group 510 maycomprise a portion of a hardware chip of the present disclosure, e.g.,hardware chip 300, hardware chip 300′, or the like.

As depicted in FIG. 5, a specialized command (e.g., amultiply-accumulate command) may be sent to processing element 530,which is paired with dedicated memory instance 520. An external host(e.g., host 350) may send the command to processing element 530 forexecution. Accordingly, the command may be executed at a given signalfrom the host by processing element 530, a specialized processingelement configurable to execute particular commands (including thereceived command). Alternatively, processing element 530 may retrievethe command from memory instance 520 for execution. Thus, in the exampleof FIG. 5, processing element 530 is a multiply-accumulate (MAC) circuitconfigured to execute MAC commands received from the external host orretrieved from memory instance 520. After execution of the command,processing group 410 may output the result of the command, e.g., to theexternal host or to a different processing group on the same hardwarechip. Although depicted with a single command and a single result, aplurality of commands may be received or retrieved and executed, and aplurality of results may be combined on processing group 510 beforeoutput.

Although depicted as a MAC circuit in FIG. 5, additional or alternativespecialized circuits may be included in processing group 510. Forexample, a MAX-read command (which returns the max value of a vector) aMAX0-read command (a common function also termed a rectifier, whichreturns the entire vector but also does MAX with 0), or the like may beimplemented.

Although depicted separately, the generalized processing group 410 ofFIG. 4 and the specialized processing group 510 of FIG. 5 may becombined. For example, a generic processor subunit may be coupled to oneor more specialized processor subunits to form a processor subunit.Accordingly, the generic processor subunit may be used for allinstructions not executable by the one or more specialized processorsubunits.

One of ordinary skill will understand that neural network implementationand other memory-intensive tasks may be handled with specialized logiccircuits. For example, database queries, packet inspection, stringcomparison, and other functions may increase in efficiency if executedby the hardware chips described herein.

A Memory-Based Architecture for Distributed Processing

On hardware chips consistent with the present disclosure, dedicatedbuses may transfer data between processor subunits on the chip and/orbetween the processor subunits and their corresponding dedicated memorybanks. The use of dedicated buses may reduce arbitration costs becausecompeting requests are either not possible or easily avoided usingsoftware rather than hardware.

FIG. 6 schematically depicts a diagrammatic representation of aprocessing group 600. Processing group 600 may be for use in a hardwarechip, e.g., hardware chip 300, hardware chip 300′, or the like.Processor subunit 610 may be connected via buses 630 to memory 620.Memory 620 may comprise a Randomly Accessible Memory (RAM) element thatstores data and code for execution by processor subunit 610. In someembodiments, memory 620 may be an N-Way memory (wherein N is a numberequal to or larger than 1 that implies the number of segments in aninterleaved memory 620). Because processor subunit 610 is coupled tomemory 620 dedicated to processor subunit 610 via bus 630, N may be keptrelatively small without compromising the execution performance. Thisrepresents an improvement over conventional multiway register files orcaches where a lower N generally results in lower execution performance,and a higher N generally results in large area and power loss.

The size of memory 620, the number of ways, and the width of bus 630 maybe adjusted to meet the requirements of tasks and applicationimplementations of a system using processing group 600 according to, forinstance, the size of data involved in the task or tasks. Memory element620 may comprise one or more types of memory known in the art, e.g.,volatile memory (such as RAM, DRAM, SRAM, phase-change RAM (PRAM),magnetoresistive RAM (MRAM), resistive RAM (ReRAM), or the like) ornon-volatile memory (such as flash or ROM). According to someembodiments, a portion of memory element 620 may comprise a first memorytype, while another portion may comprise another memory type. Forinstance, the code region of a memory element 620 may comprise a ROMelement, while a data region of the memory element 620 may comprise aDRAM element. Another example for such partitioning is storing theweights of a neural network in flash while storing the data forcalculation in DRAM.

Processor subunit 610 comprises a processing element 640 that maycomprise a processor. The processor can be pipelined or not pipelined, acustomized Reduced Instruction Set Computing (RISC) element or otherprocessing scheme, implemented on any commercial Integrated Circuit (IC)known in the art (such as ARM, ARC, RISC-V, etc.), as appreciated by oneof ordinary skill. Processing element 640 may comprise a controllerthat, in some embodiments, includes an Arithmetic Logic Unit (ALU) orother controller.

According to some embodiments, processing element 640, which executesreceived or stored code, may comprise a generic processing element and,therefore, be flexible and capable of performing a wide variety ofprocessing operations. Non-dedicated circuitry typically consumes morepower than specific-operation-dedicated circuitry when comparing thepower consumed during performance for a specific operation. Therefore,when performing specific complex arithmetic calculations, processingelement 640 may consume more power and perform less efficiently thandedicated hardware. Therefore, according to some embodiments, acontroller of processing element 640 may be designed to perform specificoperations (e.g., addition or “move” operations).

In one example, the specific operations may be performed by one or moreaccelerators 650. Each accelerator may be dedicated and programmed toperform a specific calculation (such as multiplication, floating pointvector operations, or the like). By using accelerator(s), the averagepower consumed per calculation per processor subunit may be lowered, andthe calculation throughput henceforth increases. Accelerator(s) 650 maybe chosen according to an application that the system is designed toimplement (e.g., execution of neural networks, execution of databasequeries, or the like). Accelerator(s) 650 may be configured byprocessing element 640 and may operate in tandem therewith for loweringpower consumption and accelerating calculations and computations. Theaccelerators may additionally or alternatively be used to transfer databetween memory and MUXs/DEMUXs/input/output ports (e.g., MUX 650 andDEMUX 660) of processing group 600, such as a smart DMA (direct memoryaccess) peripheral.

Accelerator(s) 650 may be configured to perform a variety of functions.For instance, one accelerator may be configured to perform 16-bitfloating point calculation or 8-bit integer calculations, which areoften used in neural networks. Another example of an acceleratorfunction is a 32-bit floating point calculation, which is often usedduring a training stage of a neural network. Yet another example of anaccelerator function is query processing, such as that used indatabases. In some embodiments, accelerator(s) 650 may comprisespecialized processing elements to perform these functions and/or may beconfigured according to configuration data, stored on the memory element620, such that it may be modified.

Accelerator(s) 650 may additionally or alternatively implement aconfigurable scripted list of memory movements to time movements of datato/from memory 620 or to/from other accelerators and/or inputs/outputs.Accordingly, as explained further below, all the data movement insidethe hardware chip using processing group 600 may use softwaresynchronization rather than hardware synchronization. For example, anaccelerator in one processing group (e.g., group 600) may transfer datafrom its input to its accelerator every tenth cycle and then output dataat the next cycle, thereby letting the information flow from the memoryof the processing group to another one.

As further depicted in FIG. 6, in some embodiments, processing group 600may further comprise at least one input multiplexer (MUX) 660 connectedto its input port and at least one output DEMUX 670 connected to itsoutput port. These MUXs/DEMUXs may be controlled by control signals (notshown) from processing element 640 and/or from one of accelerator(s)650, determined according to a current instruction being carried out byprocessing element 640 and/or the operation executed by an acceleratorof accelerator(s) 650. In some scenarios, processing group 600 may berequired (according to a predefined instruction from its code memory) totransfer data from its input port to its output port. Accordingly, oneor more of the input MUXs (e.g., MUX 660) may be directly connected viaone or more buses to an output DEMUX (e.g., DEMUX 670), in addition toeach of the DEMUXs/MUXs being connected to processing element 640 andaccelerator(s) 650.

The processing group 600 of FIG. 6 may be arrayed to form a distributedprocessor, for example, as depicted in FIG. 7A. The processing groupsmay be disposed on substrate 710 to form an array. In some embodiments,substrate 710 may comprise a semiconductor substrate, such as silicon.Additionally or alternatively, substrate 710 may comprise a circuitboard, such as a flexible circuit board.

As depicted in FIG. 7A, substrate 710 may include, disposed thereon, aplurality of processing groups, such as processing group 600.Accordingly, substrate 710 includes a memory array that includes aplurality of banks, such as banks 720 a, 720 b, 720 c, 720 d, 720 e, 720f, 720 g, and 720 h. Furthermore, substrate 710 includes a processingarray that may include a plurality of processor subunits, such assubunits 730 a, 730 b, 730 c, 730 d, 730 e, 730 f, 730 g, and 730 h.

Furthermore, as explained above, each processing group may include aprocessor subunit and one or more corresponding memory banks dedicatedto the processor subunit. Accordingly, as depicted in FIG. 7A, eachsubunit is associated with a corresponding, dedicated memory bank, e.g.:Processor subunit 730 a is associated with memory bank 720 a, processorsubunit 730 b is associated with memory bank 720 b, processor subunit730 c is associated with memory bank 720 c, processor subunit 730 d isassociated with memory bank 720 d, processor subunit 730 e is associatedwith memory bank 720 e, processor subunit 730 f is associated withmemory bank 720 f, processor subunit 730 g is associated with memorybank 720 g, processor subunit 730 h is associated with memory bank 720h.

To allow each processor subunit to communicate with its corresponding,dedicated memory bank(s), substrate 710 may include a first plurality ofbuses connecting one of the processor subunits to its corresponding,dedicated memory bank(s). Accordingly, bus 740 a connects processorsubunit 730 a to memory bank 720 a, bus 740 b connects processor subunit730 b to memory bank 720 b, bus 740 c connects processor subunit 730 cto memory bank 720 c, bus 740 d connects processor subunit 730 d tomemory bank 720 d, bus 740 e connects processor subunit 730 e to memorybank 720 e, bus 740 f connects processor subunit 730 f to memory bank720 f, bus 740 g connects processor subunit 730 g to memory bank 720 g,and bus 740 h connects processor subunit 730 h to memory bank 720 h.Moreover, to allow each processor subunit to communicate with otherprocessor subunits, substrate 710 may include a second plurality ofbuses connecting one of the processor subunits to another of theprocessor subunits. In the example of FIG. 7A, bus 750 a connectsprocessor subunit 730 a to processor subunit 750 e, bus 750 b connectsprocessor subunit 730 a to processor subunit 750 b, bus 750 c connectsprocessor subunit 730 b to processor subunit 750 f, bus 750 d connectsprocessor subunit 730 b to processor subunit 750 c, bus 750 e connectsprocessor subunit 730 c to processor subunit 750 g, bus 750 f connectsprocessor subunit 730 c to processor subunit 750 d, bus 750 g connectsprocessor subunit 730 d to processor subunit 750 h, bus 750 h connectsprocessor subunit 730 h to processor subunit 750 g, bus 750 i connectsprocessor subunit 730 g to processor subunit 750 g, and bus 750 jconnects processor subunit 730 f to processor subunit 750 e.

Accordingly, in the example arrangement shown in FIG. 7A, the pluralityof logic processor subunits is arranged in at least one row and at leastone column. The second plurality of buses connect each processor subunitto at least one adjacent processor subunit in the same row and to atleast one adjacent processor subunit in the same column. FIG. 7A may bereferred to as a “partial tile connection.”

The arrangement shown in FIG. 7A may be modified to form a “full tileconnection.” A full tile connection includes additional buses connectingdiagonal processor subunits. For example, the second plurality of busesmay include additional buses between processor subunit 730 a andprocessor subunit 730 f, between processor subunit 730 b and processorsubunit 730 e, between processor subunit 730 b and processor subunit 730g, between processor subunit 730 c and processor subunit 730 f, betweenprocessor subunit 730 c and processor subunit 730 h, and betweenprocessor subunit 730 d and processor subunit 730 g.

A full tile connection may be used for convolution calculations, inwhich data and results stored in a near processor subunit are used. Forexample, during convolutional image processing, each processor subunitmay receive a tile of the image (such as a pixel or a group of pixels).In order to calculate the convolution results, each processor subunitmay acquire data from all eight adjacent processor subunits, each ofwhich have received a corresponding tile. In a partial tile connection,the data from the diagonal adjacents may be passed through otheradjacent processor subunits connected to the processor subunit.Accordingly, the distributed processor on a chip may be an artificialintelligence accelerator processor.

In a specific example of a convolutional calculation, an N×M image maybe divided across a plurality of processor subunits. Each processorsubunit may perform a convolution with an A×B filter on itscorresponding tile. To perform the filtering on one or more pixels on aboundary between tiles, each processor subunit may require data fromneighboring processor subunits having tiles including pixels on the sameboundary. Accordingly, the code generated for each processor subunitconfigures the subunit to calculate the convolutions and pull from oneof the second plurality of buses whenever data is needed from anadjacent subunit. Corresponding commands to output data to the secondplurality of buses are provided to the subunits to ensure proper timingof needed data transfers.

The partial tile connection of FIG. 7A may be modified to be anN-partial tile connection. In this modification, the second plurality ofbuses may further connect each processor subunit to processor subunitswithin a threshold distance of the processor subunit (e.g., within nprocessor subunits) in the four directions along which the buses of FIG.7A run (i.e., up, down, left, and right). A similar modification may bemade to the full-tile connection (to result in an N-full tileconnection) such that the second plurality of buses further connectseach processor subunit to processor subunits within a threshold distanceof the processor subunit (e.g., within n processor subunits) in the fourdirections along which the buses of FIG. 7A run in additional to the twodiagonal directions.

Other arrangements are possible. For example, in the arrangement shownin FIG. 7B, bus 750 a connects processor subunit 730 a to processorsubunit 730 d, bus 750 b connects processor subunit 730 a to processorsubunit 730 b, bus 750 c connects processor subunit 730 b to processorsubunit 730 c, and bus 750 d connects processor subunit 730 c toprocessor subunit 730 d. Accordingly, in the example arrangement shownin FIG. 7B, the plurality of processor subunits is arranged in a starpattern. The second plurality of buses connect each processor subunit toat least one adjacent processor subunit within the star pattern.

Further arrangements (not shown) are possible. For example, a neighborconnection arrangement may be used such that the plurality of processorsubunits is arranged in one or more lines (e.g., similar to thatdepicted in FIG. 7A). In a neighbor connection arrangement, the secondplurality of buses connect each processor subunit to a processor subunitto the left in the same line, to a processor subunit to the right in thesame line, to the processor subunits both to the left and to the rightin the same line, etc.

In another example, an N-linear connection arrangement may be used. Inan N-linear connection arrangement, the second plurality of busesconnect each processor subunit to processor subunits within a thresholddistance of the processor subunit (e.g., within n processor subunits).The N-linear connection arrangement may be used with the line array(described above), the rectangular array (depicted in FIG. 7A), theelliptical array (depicted in FIG. 7B), or any other geometrical array.

In yet another example, an N-log connection arrangement may be used. Inan N-log connection arrangement, the second plurality of buses connecteach processor subunit to processor subunits within a threshold power oftwo distance of the processor subunit (e.g., within 2^(n) processorsubunits). The N-log connection arrangement may be used with the linearray (described above), the rectangular array (depicted in FIG. 7A),the elliptical array (depicted in FIG. 7B), or any other geometricalarray.

Any of the connection schemes described above may be combined for use inthe same hardware chip. For example, a full tile connection may be usedin one region while a partial tile connection is used in another region.In another example, an N-linear connection arrangement may be used inone region while an N-full tile connection is used in another region.

Alternatively to or in addition with dedicated buses between processorsubunits of the memory chip, one or more shared buses may be used tointerconnect all (or a subset of) the processor subunits of adistributed processor. Collisions on the shared buses may still beavoided by timing data transfers on the shared buses using code executedby the processor subunits, as explained further below. Additionally withor alternatively to shared buses, configurable buses may be used todynamically connect processor subunits to form groups of processorsunits connected to separated buses. For example, the configurable busesmay include transistors or other mechanisms that may be controlled byprocessor subunit to direct data transfers to a selected processorsubunit.

In both FIGS. 7A and 7B, the plurality of processor subunits of theprocessing array is spatially distributed among the plurality ofdiscrete memory banks of the memory array. In other alternativeembodiments (not shown), the plurality of processor subunits may beclustered in one or more regions of the substrate, and the plurality ofmemory banks may be clustered in one or more other regions of thesubstrate. In some embodiments, a combination of spatial distributionand clustering may be used (not shown). For example, one region of thesubstrate may include a cluster of processor subunits, another region ofthe substrate may include a cluster of memory banks, and yet anotherregion of the substrate may include processing arrays distributedamongst memory banks.

One of ordinary skill will recognize that arraying processor groups 600on a substrate is not an exclusive embodiment. For example, eachprocessor subunit may be associated with at least two dedicated memorybanks. Accordingly, processing groups 310 a, 310 b, 310 c, and 310 d ofFIG. 3B may be used in lieu of or in combination with processing group600 to form the processing array and the memory array. Other processinggroups including, for example, three, four, or more dedicated memorybanks (not shown) may be used.

Each of the plurality of processor subunits may be configured to executesoftware code associated with a particular application independently,relative to other processor subunits included in the plurality ofprocessor subunits. For example, as explained below, a plurality ofsub-series of instructions may be grouped as machine code and providedto each processor subunit for execution.

In some embodiments, each dedicated memory bank comprises at least onedynamic random access memory (DRAM). Alternatively, the memory banks maycomprise a mix of memory types, such as static random access memory(SRAM), DRAM, Flash or the like.

In conventional processors, data sharing between processor subunits isusually performed with shared memory. Shared memory typically requires alarge portion of chip area and/or performed a bus that is managed byadditional hardware (such as arbiters). The bus results in bottlenecks,as described above. In addition, the shared memory, which may beexternal to the chip, typically includes cache coherency mechanisms andmore complex caches (e.g., L1 cache, L2 cache, and shared DRAM) in orderto provide accurate and up-to-date data to the processor subunits. Asexplained further below, the dedicated buses depicted in FIGS. 7A and 7Ballow for hardware chips that are free of hardware management (such asarbiters). Moreover, the use of dedicated memories as depicted in FIGS.7A and 7B allow for the elimination of complex caching layers andcoherency mechanism.

Instead, in order to allow each processor subunit to access datacalculated by other processor subunits and/or stored in memory banksdedicated to the other processor subunits, buses are provided whosetiming is performed dynamically using code individually executed by eachprocessor subunit. This allows for elimination of most, if not all, busmanagement hardware as conventionally used. Moreover, complex cachingmechanisms are replaced with direct transfers over these buses,resulting in lower latency times during memory reads and writes.

Memory-Based Processing Arrays

As depicted in FIGS. 7A and 7B, a memory chip of the present disclosuremay operate independently. Alternatively, memory chips of the presentdisclosure may be operably connected with one or more additionalintegrated circuits, such as a memory device (e.g., one or more DRAMbanks), a system-on-a-chip, a field-programmable gate array (FPGA), orother processing and/or memory chip. In such embodiments, tasks in aseries of instructions executed by the architecture may be divided(e.g., by a compiler, as described below) between processor subunits ofthe memory chip and any processor subunits of the additional integratedcircuit(s). For example, the other integrated circuits may comprise ahost (e.g., host 350 of FIG. 3A) that inputs instructions and/or data tothe memory chip and receives output therefrom.

In order to interconnect memory chips of the present disclosure with oneor more additional integrated circuits, the memory chip may include amemory interface, such as a memory interface complying with a JointElectron Device Engineering Council (JEDEC) standard or any of itsvariants. The one or more additional integrated circuits may thenconnect to the memory interface. Accordingly, if the one or moreadditional integrated circuits are connected to a plurality of memorychips of the present disclosure, data may be shared between the memorychips through the one or more additional integrated circuits.Additionally or alternatively, the one or more additional integratedcircuits may include buses to connect to buses on the memory chips ofthe present disclosure such that the one or more additional integratedcircuits may execute code in tandem with the memory chips of the presentdisclosure. In such embodiments, the one or more additional integratedcircuits further assist with distributed processing even though they maybe on different substrates than the memory chips of the presentdisclosure.

Furthermore, memory chips of the present disclosure may be arrayed inorder to form an array of distributed processors. For example, one ormore buses may connect a memory chip 770 a to an additional memory chip770 b, as depicted in FIG. 7C. In the example of FIG. 7C, memory chip770 a includes processor subunits with one or more corresponding memorybanks dedicated to each processor subunit, e.g.: Processor subunit 730 ais associated with memory bank 720 a, processor subunit 730 b isassociated with memory bank 720 b, processor subunit 730 e is associatedwith memory bank 720 c, and processor subunit 730 f is associated withmemory bank 720 d. Buses connect each processor subunit to itscorresponding memory bank. Accordingly, bus 740 a connects processorsubunit 730 a to memory bank 720 a, bus 740 b connects processor subunit730 b to memory bank 720 b, bus 740 c connects processor subunit 730 eto memory bank 720 c, and bus 740 d connects processor subunit 730 f tomemory bank 720 d. Moreover, bus 750 a connects processor subunit 730 ato processor subunit 750 e, bus 750 b connects processor subunit 730 ato processor subunit 750 b, bus 750 c connects processor subunit 730 bto processor subunit 750 f, and bus 750 d connects processor subunit 730e to processor subunit 750 f. Other arrangements of memory chip 770 amay be used, for example, as described above.

Similarly, memory chip 770 b includes processor subunits with one ormore corresponding memory banks dedicated to each processor subunit,e.g.: Processor subunit 730 c is associated with memory bank 720 e,processor subunit 730 d is associated with memory bank 720 f, processorsubunit 730 g is associated with memory bank 720 g, and processorsubunit 730 h is associated with memory bank 720 h. Buses connect eachprocessor subunit to its corresponding memory bank. Accordingly, bus 740e connects processor subunit 730 c to memory bank 720 e, bus 740 fconnects processor subunit 730 d to memory bank 720 f, bus 740 gconnects processor subunit 730 g to memory bank 720 g, and bus 740 hconnects processor subunit 730 h to memory bank 720 h. Moreover, bus 750g connects processor subunit 730 c to processor subunit 750 g, bus 750 hconnects processor subunit 730 d to processor subunit 750 h, bus 750 iconnects processor subunit 730 c to processor subunit 750 d, and bus 750j connects processor subunit 730 g to processor subunit 750 h. Otherarrangements of memory chip 770 b may be used, for example, as describedabove.

The processor subunits of memory chip 770 a and 770 b may be connectedusing one or more buses. Accordingly, in the example of FIG. 7C, bus 750e may connect processor subunit 730 b of memory chip 770 a and processorsubunit 730 c of memory chip 770 b, and bus 750 f may connect processorsubunit 730 f of memory chip 770 a and processor subunit 730 c of memory770 b. For example, bus 750 e may serve as an input bus to memory chip770 b (and thus an output bus for memory chip 770 a) while bus 750 f mayserve as an input bus to memory chip 770 a (and thus an output bus formemory chip 770 b) or vice versa. Alternatively, buses 750 e and 750 fmay both server as two-way buses between memory chips 770 a and 770 b.

Buses 750 e and 750 f may include direct wires or may be interleaved ona high-speed connection in order to reduce the pins used for theinter-chip interface between memory chip 770 a and integrated circuit770 b. Moreover, any of the connection arrangements described above usedin the memory chip itself may be used to connect the memory chip to oneor more additional integrated circuits. For example, memory chip 770 aand 770 b may be connected using a full-tile or partial-tile connectionrather than only two buses as shown in FIG. 7C.

Accordingly, although depicted using buses 750 e and 750 f, architecture760 may include fewer buses or additional buses. For example, a singlebus between processor subunits 730 b and 730 c or between processorsubunits 730 f and 730 c may be used. Alternatively, additional buses,e.g., between processor subunits 730 b and 730 d, between processorsubunits 730 f and 730 d, or the like, may be used.

Furthermore, although depicted as using a single memory chip and anadditional integrated circuit, a plurality of memory chips may beconnected using buses as explained above. For example, as depicted inthe example of FIG. 7C, memory chips 770 a, 770 b, 770 c, and 770 d areconnected in an array. Each memory chip includes processor subunits anddedicated memory banks similar to the memory chips described above.Accordingly, a description of these components is not repeated here.

In the example of FIG. 7C, memory chips 770 a, 770 b, 770 c, and 770 dare connected in a loop. Accordingly, bus 750 a connects memory chips770 a and 770 d, bus 750 c connects memory chips 770 a and 770 b, bus750 e connects memory chips 770 b and 770 c, and bus 750 g connectsmemory chips 770 c and 770 d. Although memory chips 770 a, 770 b, 770 c,and 770 d may be connected with full-tile connections, partial-tileconnections, or other connection arrangements, the example of FIG. 7Callows for fewer pin connections between memory chips 770 a, 770 b, 770c, and 770 d.

Relatively Large Memories

Embodiments of the present disclosure may use dedicated memories ofrelatively large size as compared with shared memories of conventionalprocessors. The use of dedicated memories rather than shared memoriesallows for gains in efficiency to continue without tapering off withmemory increases. This allows for memory-intensive tasks such as neuralnetwork processing and database queries to be performed more efficientlythan in conventional processors, where the efficiency gains ofincreasing shared memory taper off due to the von Neumann bottleneck.

For example, in distributed processors of the present disclosure, amemory array disposed on the substrate of the distributed processor mayinclude a plurality of discrete memory banks. Each of the discretememory banks may have a capacity greater than one megabyte, as well as aprocessing array disposed on the substrate, including a plurality ofprocessor subunits. As explained above, each one of the processorsubunits may be associated with a corresponding, dedicated one of theplurality of discrete memory banks. In some embodiments, the pluralityof processor subunits may be spatially distributed among the pluralityof discrete memory banks within the memory array. By using dedicatedmemories of at least one megabyte, rather than shared caches of a fewmegabytes for a large CPU or GPU, the distributed processors of thepresent disclosure gain efficiencies that are not possible inconventional systems due to the von Neumann bottleneck in CPUs and GPUs.

Different memories may be used as the dedicated memories. For example,each dedicated memory bank may comprise at least one DRAM bank.Alternatively, each dedicated memory bank may comprise at least onestatic random access memory bank. In other embodiments, different typesof memories may be combined on a single hardware chip.

As explained above, each dedicated memory may be at least one megabyte.Accordingly, each dedicated memory bank may be the same size or at leasttwo of the plurality of memory banks may have different sizes.

Moreover, as described above, the distributed processor may include afirst plurality of buses, each connecting one of the plurality ofprocessor subunits to a corresponding, dedicated memory bank and asecond plurality of buses, each connecting one of the plurality ofprocessor subunits to another one of the plurality of processorsubunits.

Synchronization Using Software

As explained above, hardware chips of the present disclosure may managedata transfers using software rather than hardware. In particular,because the timings of transfers on the buses, reads and writes to thememories, and calculations of the processor subunits are set by thesub-series of instructions executed by the processor subunits, hardwarechips of the present disclosure may execute code to prevent collisionson the buses. Accordingly, hardware chips of the present disclosure mayavoid hardware mechanisms conventionally used to manage data transfers(such as network controllers within in a chip, packet parsers andpackets transferors between processor subunits, bus arbitrators, aplurality of buses to avoid arbitration, or the like).

If hardware chips of the present disclosure transferred dataconventionally, connecting N processor subunits with buses would requirebus arbitration or wide MUXs controlled by an arbiter. Instead, asdescribed above, embodiments of the present disclosure may use a busthat is only a wire, an optical cable, or the like between processorsubunits, where the processor subunits individually execute code toavoid collision on the buses. Accordingly, embodiments of the presentdisclosure may preserve space on the substrate as well as materials costand efficiency losses (e.g., due to power and time consumption byarbitration). The efficiency and space gains are even greater whencompared to other architectures using first-in-first-out (FIFO)controllers and/or mailboxes.

Furthermore, as explained above, each processor subunit may include oneor more accelerators in addition to one or more processing elements. Insome embodiments, the accelerator(s) may read and write from the busesrather than the processing element(s). In such embodiments, additionalefficiency may be obtained by allowing the accelerator(s) to transmitdata during the same cycle in which the processing element(s) performone or more calculations. Such embodiments, however, require additionalmaterials for the accelerator(s). For example, additional transistorsmay be required for fabrication of the accelerator(s).

The code also may account for the internal behavior, including timingand latencies, of the processor subunits (e.g., including the processingelements and/or accelerators forming part of the processor subunit). Forexample, a compiler (as described below) may perform pre-processing thataccounts for the timing and latencies when generating the sub-series ofinstructions that control the data transfers.

In one example, a plurality of processor subunits may be assigned a taskof calculating a neural network layer containing a plurality of neuronsfully-connected to a previous layer of a larger plurality of neurons.Assuming data of the previous layer is evenly spread between theplurality of processor subunits, one way to perform the calculation maybe to configure each processor subunit to transmit the data of theprevious layer to the main bus in turn and then each processor subunitwill multiply this data by the weight of the corresponding neuron thatthe subunit implements. Because each processor subunit calculates morethan one neuron, each processor subunit will transmit the data of theprevious layer a number of times equal to the number of neurons. Thus,the code of each processor subunit is not the same as the code for otherprocessor subunits because the subunits will transmit at differenttimes.

In some embodiments, a distributed processor may comprise a substrate(e.g., a semiconductor substrate, such as silicon and/or a circuitboard, such as a flexible circuit board) with a memory array disposed onthe substrate, the memory array including a plurality of discrete memorybanks, and a processing array disposed on the substrate, the processingarray including a plurality of processor subunits, as depicted, e.g., inFIGS. 7A and 7B. As explained above, each one of the processor subunitsmay be associated with a corresponding, dedicated one of the pluralityof discrete memory banks. Moreover, as depicted, e.g., in FIGS. 7A and7B, the distributed processor may further comprise a plurality of buses,each one of the plurality of buses connecting one of the plurality ofprocessor subunits to at least another one of the plurality of processorsubunits.

As explained above, the plurality of buses may be controlled insoftware. Accordingly, the plurality of buses may be free of timinghardware logic components such that data transfers between processorsubunits and across corresponding ones of the plurality of buses areuncontrolled by timing hardware logic components. In one example, theplurality of buses may be free of bus arbiters such that data transfersbetween processor subunits and across corresponding ones of theplurality of buses are uncontrolled by bus arbiters.

In some embodiments, as depicted, e.g., in FIGS. 7A and 7B, thedistributed processor may further comprise a second plurality of busesconnecting one of the plurality of processor subunits to acorresponding, dedicated memory bank. Similar to the plurality of busesdescribed above, the second plurality of buses may be free of timinghardware logic components such that data transfers between processorsubunits and corresponding, dedicated memory banks are uncontrolled bytiming hardware logic components. In one example, the second pluralityof buses may be free of bus arbiters such that data transfers betweenprocessor subunits and corresponding, dedicated memory banks areuncontrolled by bus arbiters.

As used herein, the phrase “free of” does not necessarily imply theabsolute absence of components, such as timing hardware logic components(e.g., bus arbiters, arbitration trees, FIFO controllers, mailboxes, orthe like). Such components may still be included in a hardware chipdescribed as “free of” those components. Instead, the phrase “free of”refers to the function of the hardware chip; that is, a hardware chip“free of” timing hardware logic components controls the timing of itsdata transfers without use of the timing hardware logic components, ifany, included therein. For example, a hardware chip that executes codeincluding sub-series of instructions that control data transfers betweenprocessor subunits of the hardware chip, even if the hardware chipincludes timing hardware logic components as a secondary precaution toprotect against collisions due to errors in the executed code.

As explained above, the plurality of buses may comprise at least one ofwires or optical fibers between corresponding ones of the plurality ofprocessor subunits. Accordingly, in one example, a distributed processorfree of timing hardware logic components may include only wires oroptical fibers without bus arbiters, arbitration trees, FIFOcontrollers, mailboxes, or the like.

In some embodiments, the plurality of processor subunits is configuredto transfer data across at least one of the plurality of buses inaccordance with code executed by the plurality of processor subunits.Accordingly, as explained below, a compiler may organize sub-series ofinstructions, each sub-series comprising code executed by a singleprocessor subunit. The sub-series instructions may instruct theprocessor subunit when to transfer data onto one of the buses and whento retrieve data from the buses. When the sub-series are executed intandem across the distributed processor, the timing of transfers betweenthe processor subunits may be governed by the instructions to transferand retrieve included in the sub-series. Thus, the code dictates timingof data transfers across at least one of the plurality of buses. Thecompiler may generate code to be executed by a single processor subunit.Additionally, the compiler may generate code to be executed by groups ofprocessor subunits. In some cases, the compiler may treat all theprocessor subunits together as if they were one super-processor (e.g., adistributed processor), and the compiler may generate code for executionby that defined super-processor/distributed processor.

As explained above and depicted in FIGS. 7A and 7B, the plurality ofprocessor subunits may be spatially distributed among the plurality ofdiscrete memory banks within the memory array. Alternatively, theplurality of processor subunits may be clustered in one or more regionsof the substrate, and the plurality of memory banks may be clustered inone or more other regions of the substrate. In some embodiments, acombination of spatial distribution and clustering may be used, asexplained above.

In some embodiments, a distributed processor may comprise a substrate(e.g., a semiconductor substrate, including silicon and/or a circuitboard, such as a flexible circuit board) with a memory array disposed onthe substrate, the memory array including a plurality of discrete memorybanks. A processing array may also be disposed on the substrate, theprocessing array including a plurality of processor subunits, asdepicted, e.g., in FIGS. 7A and 7B. As explained above, each one of theprocessor subunits may be associated with a corresponding, dedicated oneof the plurality of discrete memory banks. Moreover, as depicted, e.g.,in FIGS. 7A and 7B, the distributed processor may further comprise aplurality of buses, each one of the plurality of buses connecting one ofthe plurality of processor subunits to a corresponding, dedicated one ofthe plurality of discrete memory banks.

As explained above, the plurality of buses may be controlled insoftware. Accordingly, the plurality of buses may be free of timinghardware logic components such that data transfers between a processorsubunit and a corresponding, dedicated one of the plurality of discretememory banks and across a corresponding one of the plurality of busesare not controlled by timing hardware logic components. In one example,the plurality of buses may be free of bus arbiters such that datatransfers between processor subunits and across corresponding ones ofthe plurality of buses are uncontrolled by bus arbiters.

In some embodiments, as depicted, e.g., in FIGS. 7A and 7B, thedistributed processor may further comprise a second plurality of busesconnecting one of the plurality of processor subunits to at leastanother one of the plurality of processor subunits. Similar to theplurality of buses described above, the second plurality of buses may befree of timing hardware logic components such that data transfersbetween processor subunits and corresponding, dedicated memory banks areuncontrolled by timing hardware logic components. In one example, thesecond plurality of buses may be free of bus arbiters such that datatransfers between processor subunits and corresponding, dedicated memorybanks are uncontrolled by bus arbiters.

In some embodiments, the distributed processor may use a combination ofsoftware timing with hardware timing components. For example, adistributed processor may comprise a substrate (e.g., a semiconductorsubstrate, including silicon and/or a circuit board, such as a flexiblecircuit board) with a memory array disposed on the substrate, the memoryarray including a plurality of discrete memory banks. A processing arraymay also be disposed on the substrate, the processing array including aplurality of processor subunits, as depicted, e.g., in FIGS. 7A and 7B.As explained above, each one of the processor subunits may be associatedwith a corresponding, dedicated one of the plurality of discrete memorybanks. Moreover, as depicted, e.g., in FIGS. 7A and 7B, the distributedprocessor may further comprise a plurality of buses, each one of theplurality of buses connecting one of the plurality of processor subunitsto at least another one of the plurality of processor subunits.Moreover, as explained above, the plurality of processor subunits may beconfigured to execute software that controls timing of data transfersacross the plurality of buses to avoid colliding data transfers on atleast one of the plurality of buses. In such an example, the softwaremay control the timing of the data transfers, but the transfersthemselves may be controlled, at least in part, by one or more hardwarecomponents.

In such embodiments, the distributed processor may further comprise asecond plurality of buses connecting one of the plurality of processorsubunits to a corresponding, dedicated memory bank. Similar to theplurality of buses described above, the plurality of processor subunitsmay be configured to execute software that controls timing of datatransfers across the second plurality of buses to avoid colliding datatransfers on at least one of the second plurality of buses. In such anexample, as explained above, the software may control the timing of thedata transfers, but the transfers themselves may be controlled, at leastin part, by one or more hardware components.

Division of Code

As explained above, hardware chips of the present disclosure may executecode in parallel across processor subunits included on a substrateforming the hardware chip. Additionally, hardware chips of the presentdisclosure may perform multitasking. For example, hardware chips of thepresent disclosure may perform area multitasking, in which one group ofprocessor subunits of the hardware chip execute one task (e.g., audioprocessing) while another group of processor subunits of the hardwarechip execute another task (e.g., image processing). In another example,hardware chips of the present disclosure may perform timingmultitasking, in which one or more processor subunits of the hardwarechip execute one task during a first period of time and another taskduring a second period of time. A combination of area and timingmultitasking may also be used such that one task may be assigned to afirst group of processor subunits during a first period of time whileanother task may be assigned to a second group of processor subunitsduring the first period of time, after which a third task may beassigned to processor subunits included in the first group and thesecond group during a second period of time.

In order to organize machine code for execution on memory chips of thepresent disclosure, machine code may be divided between processorsubunits of the memory chip. For example, a processor on a memory chipmay comprise a substrate and a plurality of processor subunits disposedon the substrate. The memory chip may further comprise a correspondingplurality of memory banks disposed on the substrate, each one of theplurality processor subunits being connected to at least one dedicatedmemory bank not shared by any other processor subunit of the pluralityof processor subunits. Each processor subunit on the memory chip may beconfigured to execute a series of instructions independent from otherprocessor subunits. Each series of instructions may be executed byconfiguring one or more general processing elements of the processorsubunit in accordance with code defining the series of instructionsand/or by activating one or more special processing elements (e.g., oneor more accelerators) of the processor subunit in accordance with asequence provided in the code defining the series of instructions.

Accordingly, each series of instructions may define a series of tasks tobe performed by a single processor subunit. A single task may comprisean instruction within an instruction set defined by the architecture ofone or more processing elements in the processor subunit. For example,the processor subunit may include particular registers, and a singletask may push data onto a register, pull data from a register, performan arithmetic function on data within a register, perform a logicoperation on data within a register, or the like. Moreover, theprocessor subunit may be configured for any number of operands, such asa 0-operand processor subunit (also called a “stack machine”), a1-operand processor subunit (also called an accumulator machine), a2-operand processor subunit (such as a RISC), a 3-operand processorsubunit (such as a complex instruction set computer (CISC)), or thelike. In another example, the processor subunit may include one or moreaccelerators, and a single task may activate an accelerator to perform aspecific function, such as a MAC function, a MAX function, a MAX-0function, or the like.

The series of instructions may further include tasks for reading andwriting from the dedicated memory banks of the memory chip. For example,a task may include writing a piece of data to a memory bank dedicated tothe processor subunit executing the task, reading a piece of data from amemory bank dedicated to the processor subunit executing the task, orthe like. In some embodiments, the reading and writing may be performedby the processor subunit in tandem with a controller of the memory bank.For example, the processor subunit may execute a read or write task bysending a control signal to the controller to perform the read or write.In some embodiments, the control signal may include a particular addressto use for reads and writes. Alternatively, the processor subunit maydefer to the memory controller to select an available address for thereads and writes.

Additionally or alternatively, the reading and writing may be performedby one or more accelerators in tandem with a controller of the memorybank. For example, the accelerators may generate the control signals forthe memory controller, similar to how the processor subunit generatescontrol signals, as described above.

In any of the embodiments described above, an address generator may alsobe used to direct the reads and writes to specific addresses of a memorybank. For example, the address generator may comprise a processingelement configured to generate memory addresses for reads and writes.The address generator may be configured to generate addresses in orderto increase efficiency, e.g., by writing results of a later calculationto the same address as the results of a former calculation that are nolonger needed. Accordingly, the address generator may generate thecontrols signals for the memory controller, either in response to acommand from the processor subunit (e.g., from a processing elementincluded therein or from one or more accelerator(s) therein) or intandem with the processor subunit. Additionally or alternatively, theaddress generator may generate the addresses based on some configurationor registers for example generating a nested loop structure to iterateon certain addresses in the memory at a certain pattern.

In some embodiments, each series of instructions may comprise a set ofmachine code defining a corresponding series of tasks. Accordingly, theseries of tasks described above may be encapsulated within machine codecomprising the series of instructions. In some embodiments, as explainedbelow with respect to FIG. 8, the series of tasks may be defined by acompiler configured to distribute a higher-level series of tasks amongstthe plurality of logic circuits as a plurality of series of tasks. Forexample, the compiler may generate the plurality of series of tasksbased on the higher-level series of tasks such that the processorsubunits, executing each corresponding series of tasks in tandem,perform the same function as outlined by the higher-level series oftasks.

As explained further below, the higher-level series of tasks maycomprise a set of instructions in a human-readable programming language.Correspondingly, the series of tasks for each processor subunit maycomprise lower-level series of tasks, each of which comprises a set ofinstructions in a machine code.

As explained above with respect to FIGS. 7A and 7B, the memory chip mayfurther comprise a plurality of buses, each bus connecting one of theplurality of processor subunits to at least one other of the pluralityof processor subunits. Moreover, as explained above, data transfers onthe plurality of buses may be controlled using software. Accordingly,data transfers across at least one of the plurality of buses may bepredefined by the series of instructions included in a processor subunitconnected to the at least one of the plurality of buses. Therefore, oneof the tasks included in the series of instructions may includeoutputting data to one of the buses or pulling data from one of thebuses. Such tasks may be executed by a processing element of theprocessor subunit or by one or more accelerators included in theprocessor subunit. In the latter embodiment, the processor subunit mayperform a calculation or send a control signal to a corresponding memorybank in the same cycle during which accelerator(s) pull data from orplace data on one of the buses.

In one example, the series of instructions included in the processorsubunit connected to the at least one of the plurality of buses mayinclude a sending task that comprises a command for the processorsubunit connected to the at least one of the plurality of buses to writedata to the at least one of the plurality of buses. Additionally oralternatively, the series of instructions included in the processorsubunit connected to the at least one of the plurality of buses mayinclude a receiving task that comprises a command for the processorsubunit connected to the at least one of the plurality of buses to readdata from the at least one of the plurality of buses.

Additionally or alternatively to distribution of code amongst processorsubunits, data may be divided between memory banks of the memory chip.For example, as explained above, a distributed processor on a memorychip may comprise a plurality of processor subunits disposed on thememory chip and a plurality of memory banks disposed on the memory chip.Each one of the plurality of memory banks may be configured to storedata independent from data stored in other ones of the plurality ofmemory banks, and each one of the plurality of processor subunits may beconnected to at least one dedicated memory bank from among the pluralityof memory banks. For example, each processor subunit may have access toone or more memory controllers of one or more corresponding memory banksdedicated to the processor subunit, and no other processor subunit mayhave access to these corresponding one or more memory controllers.Accordingly, the data stored in each memory bank may be unique to thededicated processor subunit. Moreover, the data stored in each memorybank may be independent of the memory stored in other memory banksbecause no memory controllers may be shared between memory banks.

In some embodiments, as described below with respect to FIG. 8, the datastored in each of the plurality of memory banks may be defined by acompiler configured to distribute data amongst the plurality of memorybanks. Moreover, the compiler may be configured to distribute datadefined in a higher-level series of tasks amongst the plurality ofmemory banks using a plurality of lower-level tasks distributed amongstcorresponding processor subunits.

As explained further below, the higher-level series of tasks maycomprise a set of instructions in a human-readable programming language.Correspondingly, the series of tasks for each processor subunit maycomprise lower-level series of tasks, each of which comprises a set ofinstructions in a machine code.

As explained above with respect to FIGS. 7A and 7B, the memory chip mayfurther comprise a plurality of buses, each bus connecting one of theplurality of processor subunits to one or more corresponding, dedicatedmemory banks from among the plurality of memory banks. Moreover, asexplained above, data transfers on the plurality of buses may becontrolled using software. Accordingly, data transfers across aparticular one of the plurality of buses may be controlled by acorresponding processor subunit connected to the particular one of theplurality of buses. Therefore, one of the tasks included in the seriesof instructions may include outputting data to one of the buses orpulling data from one of the buses. As explained above, such tasks maybe executed by (i) a processing element of the processor subunit or (ii)one or more accelerators included in the processor subunit. In thelatter embodiment, the processor subunit may perform a calculation oruse buses connecting the processor subunit to other processor subunitsin the same cycle during which accelerator(s) pull data from or placedata on one of the buses connected to the one or more corresponding,dedicated memory banks.

Therefore, in one example, the series of instructions included in theprocessor subunit connected to the at least one of the plurality ofbuses may include a sending task. The sending task may comprise acommand for the processor subunit connected to the at least one of theplurality of buses to write data to the at least one of the plurality ofbuses for storage in the one or more corresponding, dedicated memorybanks. Additionally or alternatively, the series of instructionsincluded in the processor subunit connected to the at least one of theplurality of buses may include a receiving task. The receiving task maycomprise a command for the processor subunit connected to the at leastone of the plurality of buses to read data from the at least one of theplurality of buses for storage in the one or more corresponding,dedicated memory banks. Accordingly, the sending and receiving tasks insuch embodiments may comprise control signals that are sent, along theat least one of the plurality of buses, to one or more memorycontrollers of the one or more corresponding, dedicated memory banks.Moreover, the sending and receiving tasks may be executed by one portionof the processing subunit (e.g., by one or more accelerators thereof)concurrently with a calculation or other task executed by anotherportion of the processing subunit (e.g., by one or more differentaccelerators thereof). An example of such a concurrent execution mayinclude a MAC-relay command, in which receiving, multiplying, andsending are executed in tandem.

In addition to distributing data amongst the memory banks, particularportions of data may be duplicated across different memory banks. Forexample, as explained above, a distributed processor on a memory chipmay comprise a plurality of processor subunits disposed on the memorychip and a plurality of memory banks disposed on the memory chip. Eachone of the plurality of processor subunits may be connected to at leastone dedicated memory bank from among the plurality of memory banks, andeach memory bank of the plurality of memory banks may be configured tostore data independent from data stored in other ones of the pluralityof memory banks. Moreover, at least some of the data stored in oneparticular memory bank from among the plurality of memory banks maycomprise a duplicate of data stored in at least another one of theplurality of memory banks. For example, a number, string, or other typeof data used in the series of instructions may be stored in a pluralityof memory banks dedicated to different processor subunits rather thanbeing transferred from one memory bank to other processor subunits inthe memory chip.

In one example, parallel string matching may use data duplicationdescribed above. For example, a plurality of strings may be compared tothe same string. A conventional processor would compare each string inthe plurality to the same string in sequence. On a hardware chip of thepresent disclosure, the same string may be duplicated across the memorybanks such that the processor subunits may compare a separate string inthe plurality to the duplicated string in parallel.

In some embodiments, as described below with respect to FIG. 8, the atleast some data duplicated across the one particular memory bank fromamong the plurality of memory banks and the at least another one of theplurality of memory banks is defined by a compiler configured toduplicate data across memory banks. Moreover, the compiler may beconfigured to duplicate the at least some data using a plurality oflower-level tasks distributed amongst corresponding processor subunits.

Duplication of data may be useful for certain tasks that re-use the sameportions of data across different calculations. By duplicating theseportions of data, the different calculations may be distributed amongstprocessor subunits of the memory chip for parallel execution while eachprocessor subunit may store the portions of data in, and access thestored portions from, a dedicated memory bank (rather than pushing andpulling the portions of data across buses connecting the processorsubunits). In one example, the at least some data duplicated across theone particular memory bank from among the plurality of memory banks andthe at least another one of the plurality of memory banks may compriseweights of a neural network. In this example, each node in the neuralnetwork may be defined by at least one processor subunit from among theplurality of processor subunits. For example, each node may comprisemachine code executed by the at least one processor subunit defining thenode. In this example, duplication of the weights may allow eachprocessor subunit to execute machine code to effect, at least in part, acorresponding node while only accessing one or more dedicated memorybanks (rather than performing data transfers with other processorsubunits). Because the timing of reads and writes to the dedicatedmemory bank(s) are independent of other processor subunits while thetiming of data transfers between processor subunits requires timingsynchronization (e.g., using software, as explained above), duplicationof memory to avoid data transfers between processor subunits may producefurther efficiencies in overall execution.

As explained above with respect to FIGS. 7A and 7B, the memory chip mayfurther comprise a plurality of buses, each bus connecting one of theplurality of processor subunits to one or more corresponding, dedicatedmemory banks from among the plurality of memory banks. Moreover, asexplained above, data transfers on the plurality of buses may becontrolled using software. Accordingly, data transfers across aparticular one of the plurality of buses may be controlled by acorresponding processor subunit connected to the particular one of theplurality of buses. Therefore, one of the tasks included in the seriesof instructions may include outputting data to one of the buses orpulling data from one of the buses. As explained above, such tasks maybe executed by (i) a processing element of the processor subunit or (ii)one or more accelerators included in the processor subunit. As furtherexplained above, such tasks may include a sending task and/or areceiving tasks that comprise control signals that are sent, along theat least one of the plurality of buses, to one or more memorycontrollers of the one or more corresponding, dedicated memory banks.

FIG. 8 depicts a flowchart of a method 800 for compiling a series ofinstructions for execution on an exemplary memory chip of the presentdisclosure, e.g., as depicted in FIGS. 7A and 7B. Method 800 may beimplemented by any conventional processor, whether generic orspecial-purpose.

Method 800 may be executed as a portion of a computer program forming acompiler. As used herein, a “compiler” refers to any computer programthat converts a higher-level language (e.g., a procedural language, suchas C, FORTRAN, BASIC, or the like; an object-oriented language, such asJava, C++, Pascal, Python, or the like; etc.) to a lower-level language(e.g., assembly code, object code, machine code, or the like). Thecompiler may allow a human to program a series of instructions in ahuman-readable language, which is then converted to a machine-executablelanguage.

At step 810, the processor may assign tasks associated with the seriesof instructions to different ones of the processor subunits. Forexample, the series of instructions may be divided into subgroups, thesubgroups to be executed in parallel across the processor subunits. Inone example, a neural network may be divided into its nodes, and one ormore nodes may be assigned to separate processor subunits. In thisexample, each subgroup may comprise a plurality of nodes connectedacross different layers. Thus, a processor subunit may implement a nodefrom a first layer of the neural network, a node from a second layerconnected to the node from the first layer implemented by the sameprocessor subunit, and the like. By assigning nodes based on theirconnections, data transfers between the processor subunits may belessened, which may result in greater efficiency, as explained above.

As explained above depicted in FIGS. 7A and 7B, the processor subunitsmay be spatially distributed among the plurality of memory banksdisposed on the memory chip. Accordingly, the assignment of tasks maybe, at least in part, a spatial divisional as well as a logicaldivision.

At step 820, the processor may generate tasks to transfer data betweenpairs of the processor subunits of the memory chip, each pair ofprocessor subunits being connected by a bus. For example, as explainedabove, the data transfers may be controlled using software. Accordingly,processor subunits may be configured to push and pull data on buses atsynchronized times. The generated tasks may thus include tasks forperforming this synchronized pushing and pulling of data.

As explained above, step 820 may include pre-processing to account forthe internal behavior, including timing and latencies, of the processorsubunits. For example, the processor may use known times and latenciesof the processor subunits (e.g., the time to push data to a bus, thetime to pull data from a bus, the latency between a calculation and apush or pull, or the like) to ensure that the generated taskssynchronize. Therefore, the data transfers comprising at least one pushby one or more processor subunits and at least one pull by one or moreprocessor subunits may occur simultaneously rather than incurring adelay due to timing differences between the processor subunits,latencies of the processor subunits, or the like.

At step 830, the processor may group the assigned and generated tasksinto the plurality of groups of sub-series instructions. For example,the sub-series instructions may each comprise a series of tasks forexecution by a single processor subunit. Therefore, each of theplurality of groups of sub-series instructions may correspond to adifferent one of the plurality of processor sub-units. Accordingly,steps 810, 820, and 830 may result in dividing the series ofinstructions into a plurality of groups of sub-series instructions. Asexplained above, step 820 may ensure that any data transfers between thedifferent groups are synchronized.

At step 840, the processor may generate machine code corresponding toeach of the plurality of groups of subs-series instructions. Forexample, the higher-level code representing sub-series instructions maybe converted to lower-level code, such as machine code, executable bycorresponding processor subunits.

At step 850, the processor may assign the generated machine codecorresponding to each of the plurality of groups of subs-seriesinstructions to a corresponding one of the plurality of processorsubunits in accordance with the division. For example, the processor maylabel each sub-series instructions with an identifier of thecorresponding processor subunit. Thus, when the sub-series instructionsare uploaded to a memory chip for execution (e.g., by host 350 of FIG.3A), each sub-series may configure a correct processor subunit.

In some embodiments, assigning tasks associated with the series ofinstructions to the different ones of the processor subunits may depend,at least in part, on a spatial proximity between two or more of theprocessor subunits on the memory chip. For example, as explained above,efficiency may be increased by lessening the number of data transfersbetween processor subunits. Accordingly, the processor may minimize datatransfers that move data across more than two of processor subunits.Therefore, the processor may use a known layout of the memory chip incombination with one or more optimization algorithms (such as a greedyalgorithm) in order to assign sub-series to processor subunits in a waythat maximizes (at least locally) adjacent transfers and minimizes (atleast locally) transfers to non-neighboring processor subunits.

Method 800 may include further optimizations for the memory chips of thepresent disclosure. For example, the processor may group data associatedwith the series of instructions based on the division and assign thedata to the memory banks in accordance with the grouping. Accordingly,the memory banks may hold data used for the sub-series instructionsassigned to each processor subunit to which each memory bank isdedicated.

In some embodiments, grouping the data may include determining at leasta portion of the data to duplicate in two or more of the memory banks.For example, as explained above, some data may be used across more thanone sub-series instructions. Such data may be duplicated across thememory banks dedicated to the plurality of processor subunits to whichthe different sub-series instructions are assigned. This optimizationmay further reduce data transfers across processor subunits.

The output of method 800 may be input to a memory chip of the presentdisclosure for execution. For example, a memory chip may comprise aplurality of processor subunits and a corresponding plurality of memorybanks, each processor subunit being connected to at least one memorybank dedicated to the processor subunit, and the processor subunits ofthe memory chip may be configured to execute the machine code generatedby method 800. As explained above with respect to FIG. 3A, host 350 mayinput the machine code generated by method 800 to the processor subunitsfor execution.

Sub-Banks and Sub-Controllers

In conventional memory banks, controllers are provided at the banklevel. Each bank includes a plurality of mats, which are typicallyarranged in a rectangular manner but may be arranged in any geometricalshape. Each mat includes a plurality of memory cells, which are alsotypically arranged in a rectangular manner but may be arranged in anygeometrical shape. Each cell may store a single bit of data (e.g.,depending on whether the cell is retained at a high voltage or a lowvoltage).

An example of this conventional architecture is depicted in FIGS. 9 and10. As shown in FIG. 9, at the bank level, a plurality of mats (e.g.,mats 930-1, 930-2, 940-1, and 940-2) may form bank 900. In aconventional rectangular organization, bank 900 may be controlled acrossglobal wordlines (e.g., wordline 950) and global bitlines (e.g., bitline960). Accordingly, row decoder 910 may select the correct wordline basedon an incoming control signal (e.g., a request for a read from anaddress, a request for a write to an address, or the like) and globalsense amplifier 920 (and/or a global column decoder, not shown in FIG.9) may select the correct bitline based on the control signal. Amplifier920 may also amplify any voltage levels from a selected bank during aread operation. Although depicted as using a row decoder for initialselecting and performing amplification along columns, a bank mayadditionally or alternatively use a column decoder for initial selectingand perform amplification along rows.

FIG. 10 depicts an example of a mat 1000. For example, mat 1000 may forma portion of a memory bank, such as bank 900 of FIG. 9. As depicted inFIG. 10, a plurality of cells (e.g., cells 1030-1, 1030-2, and 1030-3)may form mat 1000. Each cell may comprise a capacitor, a transistor, orother circuitry that stores at least one bit of data. For example, acell may comprise a capacitor that is charged to represent a ‘1’ anddischarged to represent a ‘0’ or may comprise a flip-flop having a firststate representing a ‘1’ and a second state representing a ‘0.’ Aconventional mat may comprise, for example, 512 bits by 512 bits. Inembodiments where mat 1000 forms a portion of MRAM, ReRAM, or the like,a cell may comprise a transistor, resistor, capacitor or other mechanismfor isolating an ion or portion of a material that stores at least onebit of data. For example, a cell may comprise an electrolyte ion, aportion of chalcogenide glass, or the like, having a first staterepresenting a ‘1’ and a second state representing a ‘0.’

As further depicted in FIG. 10, in a conventional rectangularorganization, mat 1000 may be controlled across local wordlines (e.g.,wordline 1040) and local bitlines (e.g., bitline 1050). Accordingly,wordline drivers (e.g., wordline driver 1020-1, 1020-2, . . . , 1020-x)may control the selected wordline to perform a read, write, or refreshbased on a control signal from a controller associated with the memorybank of which mat 1000 forms a part (e.g., a request for a read from anaddress, a request for a write to an address, a refresh signal).Moreover, local sense amplifiers (e.g., local amplifiers 1010-1, 1010-2,. . . , 1010-x) and/or local column decoders (not shown in FIG. 10) maycontrol the selected bitline to perform a read, write, or refresh. Thelocal sense amplifiers may also amplify any voltage levels from aselected cell during a read operation. Although depicted as using awordline driver for initial selecting and performing amplification alongcolumns, a mat may instead use a bitline driver for initial selectingand perform amplification along rows.

As explained above, a large number of mats are duplicated to form amemory bank. Memory banks may be grouped to form a memory chip. Forexample, a memory chip may comprise eight to thirty-two memory banks.Accordingly, pairing processor subunits with memory banks on aconventional memory chip may result in only eight to thirty-twoprocessor subunits. Accordingly, embodiments of the present disclosuremay include memory chips with additional sub-bank hierarchy. Thesememory chips of the present disclosure may then include processorsubunits with memory sub-banks used as the dedicated memory banks pairedwith the processor subunits allowing for a larger number of subprocessors, which may then achieve higher parallelism and performance ofin-memory computing.

In some embodiments of the present disclosure, the global row decoderand global sense amplifier of bank 900 may be replaced with sub-bankcontrollers. Accordingly, rather than sending control signals to aglobal row decoder and a global sense amplifier of the memory bank, acontroller of the memory bank may direct the control signal to theappropriate sub-bank controller. The direction may be controlleddynamically or may be hard-wired (e.g., via one or more logic gates). Insome embodiments, fuses may be used to indicate the controller of eachsub bank or mat whether to block or pass the control signal to theappropriate sub-bank or mat. In such embodiments, faulty sub-banks maythus be deactivated using the fuses.

In one example of such embodiments, a memory chip may include aplurality of memory banks, each memory bank having a bank controller anda plurality of memory sub-banks, each memory sub-bank having a sub-bankrow decoder and a sub-bank column decoder for allowing reads and writesto locations on the memory sub-bank. Each sub-bank may comprise aplurality of memory mats, each memory mat having a plurality of memorycells and may have internally local row decoders, column decoders,and/or local sense amplifiers. The sub-bank row decoders and thesub-bank column decoders may process read and write requests from thebank controller or from a sub-bank processor subunit used for in memorycomputations on the sub-bank memory, as described below. Additionally,each memory sub-bank may further have a controller configured todetermine whether to process read requests and write requests from thebank controller and/or to forward them to the next level (e.g., of rowand column decoders on a mat) or to block the requests, e.g., to allowan internal processing element or processor subunit to access thememory. In some embodiments, the bank controller may be synchronized toa system clock. However, the sub-bank controllers may be notsynchronized to the system clock.

As explained above, the use of sub-banks may allow for the inclusion ofa larger number of processor subunits in the memory chip than ifprocessor subunits were paired with memory banks of conventional chips.Accordingly, each sub-bank may further have a processor subunit usingthe sub-bank as a dedicated memory. As explained above, the processorsubunit may comprise a RISC, a CISC, or other general-purpose processingsubunit and/or may comprise one or more accelerators. Additionally, theprocessor subunit may include an address generator, as explained above.In any of the embodiments described above, each processor subunit may beconfigured to access a sub-bank dedicated to the processor subunit usingthe row decoder and the column decoder of the sub-bank without using thebank controller. The processor sub-unit associated with the sub-bank mayalso handle the memory mats (including the decoder and memory redundancymechanisms, described below) and/or determine whether a read or writerequest from an upper level (e.g., the bank level or the memory level)is forwarded and handled accordingly.

In some embodiments, the sub-bank controller may further include aregister that stores a state of the sub-bank. Accordingly, the sub-bankcontroller may return an error if the sub-bank controller receives acontrol signal from the memory controller while the register indicatesthat the sub-bank is in use. In embodiments where each sub-bank furtherincludes a processor subunit, the register may indicate an error if theprocessor subunit in the sub-bank is accessing the memory in conflictwith an external request from the memory controller.

FIG. 11 shows an example of another embodiment of a memory bank usingsub-bank controllers. In the example of FIG. 11, bank 1100 has a rowdecoder 1110, a column decoder 1120, and a plurality of memory sub-banks(e.g., sub-banks 1170 a, 1170 b, and 1170 c) with sub-bank controllers(e.g., controllers 1130 a, 1130 b, and 1130 c). The sub-bank controllersmay include address resolvers (e.g., resolvers 1140 a, 1140 b, and 1140c), which may determine whether to pass a request to one or moresub-banks controlled by the sub-bank controller.

The sub-bank controllers may further include one or more logic circuits(e.g., logic 1150 a, 1150 b, and 1150 c). For example, a logic circuitcomprising one or more processing elements may allow for one or moreoperations, such as refreshing of cells in the sub-bank, clearing ofcells in the sub-bank, or the like, to be performed without processingrequests externally from bank 1100. Alternatively, the logic circuit maycomprise a processor subunit, as explained above, such that theprocessor sub-unit has any sub-banks controlled by the sub-bankcontroller as corresponding, dedicated memory. In the example of FIG.11, logic 1150 a may have sub-bank 1170 a as a corresponding, dedicatedmemory, logic 1150 b may have sub-bank 1170 b as a corresponding,dedicated memory, and logic 1150 c may have sub-bank 1170 c as acorresponding, dedicated memory. In any of the embodiments describedabove, the logic circuits may have buses to the sub-banks, e.g., buses1131 a, 1131 b, or 1131 c. As further depicted in FIG. 11, the sub-bankcontrollers may each include a plurality of decoders, such as a sub-bankrow decoder and a sub-bank column decoder for allowing reads and writes,either by a processing element or processor subunit or by a higher-levelmemory controller issuing commands, to locations on the memorysub-bank(s). For example, sub-bank controller 1130 a includes decoders1160 a, 1160 b, and 1160 c, sub-bank controller 1130 b includes decoders1160 d, 1160 e, and 1160 f, and sub-bank controller 1130 c includesdecoders 1160 g, 1160 h, and 1160 i. The sub-bank controllers may, basedon a request from bank row decoder 1110, select a wordline using thedecoders included in the sub-bank controllers. The described system mayallow a processing element or processor subunit of the sub-bank toaccess the memory without interrupting other banks and even othersub-banks, thereby allowing each sub-bank processor subunit to performmemory computations in parallel with the other sub-bank processorsubunits.

Furthermore, each sub-bank may comprise a plurality of memory mats, eachmemory mat having a plurality of memory cells. For example, sub-bank1170 a includes mats 1190 a-1, 1190 a-2, . . . , 1190 a-x; sub-bank 1170b includes mats 1190 b-1, 1190 b-2, . . . , 1190 b-x; and sub-bank 1170c includes mats 1190 c-1, 1190 c-2, . . . , 1190 c-3. As furtherdepicted in FIG. 11, each sub-bank may include at least one decoder. Forexample, sub-bank 1170 a includes decoder 1180 a, sub-bank 1170 bincludes decoder 1180 b, and sub-bank 1170 c includes decoder 1180 c.Accordingly, bank column decoder 1120 may select a global bitline (e.g.,bitline 1121 a or 1121 b) based on external requests while the sub-bankselected by bank row decoder 1110 may use its column decoder to select alocal bitline (e.g., bitline 1181 a or 1181 b) based on local requestsfrom the logic circuit to which the sub-bank is dedicated. Accordingly,each processor subunit may be configured to access a sub-bank dedicatedto the processor subunit using the row decoder and the column decoder ofthe sub-bank without using the bank row decoder and the bank columndecoder. Thus, each processor subunit may access a correspondingsub-bank without interrupting other sub-banks. Moreover, sub-bankdecoders may reflect accessed data to the bank decoders when the requestto the sub-bank is external to the processor subunit. Alternatively, inembodiments where each sub-bank has only one row of memory mats, thelocal bitlines may be the bitlines of the mat rather than bitlines ofthe sub-bank.

A combination of embodiments using sub-bank row decoders and sub-bankcolumn decoders with the embodiment depicted in FIG. 11 may be used. Forexample, the bank row decoder may be eliminated but the bank columndecoder retained and local bitlines used.

FIG. 12 shows an example of an embodiment of a memory sub-bank 1200having a plurality of mats. For example, sub-bank 1200 may represent aportion of sub-bank 1100 of FIG. 11 or may represent an alternativeimplementation of a memory bank. In the example of FIG. 12, sub-bank1200 includes a plurality of mats (e.g., mats 1240 a and 1240 b).Moreover, each mat may include a plurality of cells. For example, mat1240 a includes cells 1260 a-1, 1260 a-2, . . . , 1260 a-x, and mat 1240b includes cells 1260 b-1, 1260 b-2, . . . , 1260 b-x.

Each mat may be assigned a range of addresses that will be assigned tothe memory cells of the mat. These addresses may be configured atproduction such that mats may be shuffled around and such that faultedmats may be deactivated and left unused (e.g., using one or more fuses,as explained further below).

Sub-bank 1200 receives read and write requests from memory controller1210. Although not depicted in FIG. 12, requests from memory controller1210 may be filtered through a controller of sub-bank 1200 and directedto an appropriate mat of sub-bank 1200 for address resolution.Alternatively, at least a portion (e.g., higher bits) of an address of arequest from memory controller 1210 may be transmitted to all mats ofsub-bank 1200 (e.g., mats 1240 a and 1240 b) such that each mat mayprocess the full address and the request associated with the addressonly if the mat's assigned address range includes the address specifiedin the command. Similar to the sub-bank direction described above, themat determination may be dynamically controlled or may be hardwired. Insome embodiments, fuses may be used to determine the address range foreach mat, also allowing for disabling of faulty mats by assigning anillegal address range. Mats may additionally or alternatively bedisabled by other common methods or connection of fuses.

In any of the embodiments described above, each mat of the sub-bank mayinclude a row decoder (e.g., row decoder 1230 a or 1230 b) for selectionof a wordline in the mat. In some embodiments, each mat may furtherinclude fuses and comparators (e.g., 1220 a and 1220 b). As describedabove, the comparators may allow each mat to determine whether toprocess an incoming request, and the fuses may allow each mat todeactivate if faulty. Alternatively, row decoders for the bank and/orsub-bank may be used rather than a row decoder in each mat.

Furthermore, in any of the embodiments described above, a column decoderincluded in the appropriate mat (e.g., column decoder 1250 a or 1250 b)may select a local bitline (e.g., bitline 1251 or 1253). The localbitline may be connected to a global bitline of the memory bank. Inembodiments where the sub-bank has local bitlines of its own, the localbitline of the cell may be further connected to the local bitline of thesub-bank. Accordingly, data in the selected cell may be read through thecolumn decoder (and/or sense amplifier) of the cell, then through thecolumn decoder (and/or sense amplifier) of the sub-bank (in embodimentsincluding a sub-bank column decoder and/or sense amplifier), and thenthrough the column decoder (and/or sense amplifier) of the bank.

Mat 1200 may be duplicated and arrayed to form a memory bank (or amemory sub-bank). For example, a memory chip of the present disclosuremay comprise a plurality of memory banks, each memory bank having aplurality of memory sub-banks, and each memory sub-bank having asub-bank controller for processing reads and writes to locations on thememory sub-bank. Furthermore, each memory sub-bank may comprise aplurality of memory mats, each memory mat having a plurality of memorycells and having a mat row decoder and a mat column decoder (e.g., asdepicted in FIG. 12). The mat row decoders and the mat column decodersmay process read and write requests from the sub-bank controller. Forexample, the mat decoders may receive all requests and determine (e.g.,using a comparator) whether to process the request based on a knownaddress range of each mat, or the mat decoders may only receive requestswithin the known address range based on selection of a mat by thesub-bank (or bank) controller.

Controller Data Transfers

Any of the memory chips of the present disclosure may also share datausing memory controllers (or sub-bank controllers or mat controllers) inaddition to sharing data using processing subunits. For example, amemory chip of the present disclosure may comprise a plurality of memorybanks (e.g., an SRAM bank, a DRAM bank, or the like), each memory bankhaving a bank controller, a row decoder, and a column decoder forallowing reads and writes to locations on the memory bank, as well as aplurality of buses connecting each controller of the plurality of bankcontrollers to at least one other controller of the plurality of bankcontrollers. The plurality of buses may be similar to the busesconnecting the processing subunits, as described above, but connectingthe bank controllers directly rather than through the processingsubunits. Furthermore, although described as connecting the bankcontrollers, buses may additionally or alternatively connect sub-bankcontrollers and/or mat controllers.

In some embodiments, the plurality of buses may be accessed withoutinterruption of data transfers on main buses of the memory banksconnected to one or more processor subunits. Accordingly, a memory bank(or sub-bank) may transmit data to or from a corresponding processorsubunit in the same clock cycle as transmitting data to or from adifferent memory bank (or sub-bank). In embodiments where eachcontroller is connected to a plurality of other controllers, thecontrollers may be configurable for selection of one other of the othercontrollers for sending or receiving of data. In some embodiments, eachcontroller may be connected to at least one neighboring controller(e.g., pairs of spatially adjacent controllers may be connected to oneanother).

Redundant Logic in Memory Circuits

The disclosure is generally directed to a memory chip with primary logicportions for on-chip data processing. The memory chip may includeredundant logic portions, which may replace defective primary logicportions to increase the fabrication yield of the chip. Thus, the chipmay include on-chip components that allow a configuration of logicblocks in the memory chip based on individual testing of the logicportions. This feature of the chip may increase yields because a memorychip with larger areas dedicated to logic portions is more susceptibleto fabrication failures. For example, DRAM memory chips with largeredundant logic portions may be susceptible to fabrication issues thatreduce yield. However, implementing redundant logic portions may resultin increased yield and reliability because it provides a manufacturer oruser of DRAM memory chips to turn on or off full logic portions whilemaintaining the ability of high parallelism. It should be noted thathere and throughout the disclosure, example of certain memory types(such as DRAM) may be identified in order to facilitate the explanationof disclosed embodiments. It is to be understood, however, that in suchinstances the identified memory types are not intended to be limiting.Rather, memory types such as DRAM, Flash, SRAM, ReRAM, PRAM, MRAM, ROM,or any other memory may be used together with the disclosed embodimentseven if fewer examples are specifically identified in a certain sectionof the disclosure.

FIG. 13 is a block diagram of an exemplary memory chip 1300, consistentwith disclosed embodiments. Memory chip 1300 may be implemented as aDRAM memory chip. Memory chip 1300 may also be implemented as any typeof memory volatile or non-volatile, such as Flash, SRAM, ReRAM, PRAM,and/or MRAM, etc. Memory chip 1300 may include a substrate 1301 in whichan address manager 1302, a memory array 1304 including a plurality ofmemory banks, 1304(a,a) to 1304(z,z), a memory logic 1306, a businesslogic 1308, and a redundant business logic 1310 are disposed. Memorylogic 1306 and business logic 1308 may constitute primary logic blocks,while redundant business logic 1310 may constitute redundant blocks. Inaddition, memory chip 1300 may include configuration switches, which mayinclude deactivation switches 1312, and an activation switches 1314.Deactivation switches 1312 and activation switches 1314 may also bedisposed in the substrate 1301. In this Application, memory logic 1306,business logic 1308, and redundant business logic 1310 may also becollectively referred to as the “logic blocks.”

Address manager 1302 may include row and column decoders or other typeof memory auxiliaries. Alternatively, or additionally, address manager1302 may include a microcontroller or processing unit.

In some embodiments, as shown in FIG. 13, memory chip 1300 may include asingle memory array 1304 that may arrange the plurality of memory blocksin a two-dimensional array on substrate 1301. In other embodiments,however, memory chip 1300 may include multiple memory arrays 1304 andeach of the memory arrays 1304 may arrange memory blocks in differentconfigurations. For example, memory blocks in at least one of the memoryarrays (also known as memory banks) may be arranged in a radialdistribution to facilitate routing between address manager 1302 ormemory logic 1306 to the memory blocks.

Business logic 1308 may be used to do the in-memory computation of anapplication that is not related to the logic used to manage the memoryitself. For example, business logic 1308 may implement functions relatedto AI such as floating, integer, or MAC operations used as activationfunctions. In addition, business logic 1308 may implement data baserelated functions like min, max, sort, count, among others. Memory logic1306 may perform tasks related to memory management, including (but notlimited to) read, write, and refresh operations. Therefore, businesslogic may be added in one or more of the bank level, mats level, or agroup of mats level. Business logic 1308 may have one or more addressoutputs and one or more data inputs/outputs. For instance, businesslogic 1308 can address by row\column lines to address manager 1302. Incertain embodiments, however, the logic blocks may be additionally oralternatively addressed via data inputs\outputs.

Redundant business logic 1310 may be a replicate of business logic 1308.In addition, redundant business logic 1310 may be connected todeactivation switches 1312 and/or activation switches 1314, which mayinclude small fuse\anti-fuse, and used for logic disabling or enablingone of the instances (e.g., an instance which is connected by default)and enable one of the other logic blocks (e.g., an instance which isdisconnected by default). In some embodiments, as further described inconnection to FIG. 15, the redundancy of blocks may be local within alogic block, such as business logic 1308.

In some embodiments, the logic blocks in memory chip 1300 may beconnected to subsets of memory array 1304 with dedicated buses. Forexample, a set of memory logic 1306, business logic 1308, and redundantbusiness logic 1310 may be connected to the first row of memory blocksin memory array 1304 (i.e., memory blocks 1304(a,a) to 1304(a,z)). Thededicated buses may allow associated logic blocks to quickly access datafrom the memory blocks without requirements of opening communicationlines through, for example, address manager 1302.

Each of the plurality of primary logic blocks may be connected to atleast one of the plurality of memory banks 1304. Also, redundant blocks,such as redundant business block 1310, may be connected to at least oneof the memory instances 1304(a,a)-(z,z). Redundant blocks may replicateat least one of the plurality of primary logic blocks, such as memorylogic 1306 or business logic 1308. Deactivation switches 1312 may beconnected to at least one of the plurality of primary logic blocks andactivation switches 1314 may be connected to at least one of theplurality of redundant blocks.

In these embodiments, upon detecting of a fault associated with one ofthe plurality of primary logic blocks (memory logic 1306 and/or businesslogic 1308), deactivation switches 1312 may be configured to disable theone of the plurality of primary logic blocks. Simultaneously, activationswitches 1314 may be configured to enable one of the plurality ofredundant blocks, such as redundant logic block 1310, that replicatesthe one of the plurality of primary logic blocks.

In addition, activation switches 1314 and deactivation switches 1312,which may collectively be referred to as “configuration switches,” mayinclude an external input to configure the status of the switch. Forinstance, activation switches 1314 may be configured so an activationsignal in the external input causes a closed switch condition, whiledeactivation switches 1312 may be configured so a deactivation signal inthe external input causes an open switch condition. In some embodiments,all configuration switches in 1300 may be deactivated by default andbecome activated or enabled after a test indicates an associated logicblock is functional and a signal is applied in the external input.Alternatively, in some cases, all configuration switches in 1300 may beenabled by default and may be deactivated or disabled after a testindicates an associated logic block is not functional and a deactivationsignal is applied in the external input.

Regardless of whether a configuration switch is initially enabled ordisabled, upon detection of a fault associated with an associated logicblock, the configuration switch may disable the associated logic block.In cases where the configuration switch is initially enabled, the stateof the configuration switch may be changed to disabled in order todisable the associated logic block. In cases where the configurationswitch is initially disabled, the state of the configuration switch maybe left in its disabled state in order to disable the associated logicblock. For example, the result of an operability test may indicate thata certain logic block is nonoperational or that it fails to operatewithin certain specifications. In such cases, the logic block may bedisabled my not enabling its corresponding configuration switch.

In some embodiments, configuration switches may be connected to two ormore logic blocks and may be configured to choose between differentlogic blocks. For example, a configuration switch may be connected toboth business logic 1308 and redundant logic block 1310. Configurationswitch may enable redundant logic block 1310 while disabling businesslogic 1308.

Alternatively, or additionally, at least one of the plurality of primarylogic blocks (memory logic 1306 and/or business logic 1308) may beconnected to a subset of the plurality of memory banks or memoryinstances 1304 with a first dedicated connection. Then, at least one ofthe plurality of redundant blocks (such as redundant business logic1310), which replicates the at least one of the plurality of primarylogic blocks, may be connected to the subset of the same plurality ofmemory banks or instances 1304 with a second dedicated connection.

Moreover, memory logic 1306 may have different functions andcapabilities than business logic 1308. For example, while memory logic1306 may be designed to enable read and write operations in the memorybank 1304, business logic 1308 may be designed to perform in-memorycomputations. Therefore, if the business logic 1308 includes a firstbusiness logic block, and the business logic 1308 includes a secondbusiness logic block (like redundant business logic 1310), it ispossible to disconnect defective business logic 1308 and reconnectredundant business logic 1310 without missing any capability.

In some embodiments, configuration switches (including deactivationswitches 1312 and activation switches 1314) may be implemented with afuse, an anti-fuse, or a programmable device (including a one-timeprogrammable device), or other form of non-volatile memory.

FIG. 14 is a block diagram of an exemplary redundant logic block set1400, consistent with disclosed embodiments. In some embodiments,redundant logic block set 1400 may be disposed in substrate 1301.Redundant logic block set 1400 may include at least one of businesslogic 1308, and redundant business logic 1310, connected to switches1312 and 1314, respectively. In addition, business logic 1308 andredundant business logic 1310 may be connected to an address bus 1402and a data bus 1404.

In some embodiments, as shown in FIG. 14, the switches 1312 and 1314 mayconnect logic blocks to a clock node. In this way, the configurationswitches may engage or disengage the logic blocks from the clock signal,effectively activating or deactivating the logic blocks. In otherembodiments, however, switches 1312 and 1314 may connect logic blocks toother nodes for activation or deactivation. For instance, configurationswitches may connect logic blocks to a voltage supply node (e.g., VCC)or to the ground node (e.g., GND) or clock signal. In this way, thelogic blocks may be enabled or disabled by the configuration switchesbecause they would create an open circuit or cut-off the logic blockpower supply.

In some embodiments, as shown in FIG. 14, address bus 1402 and data bus1404 may be in opposite sides of the logic blocks, which are connectedin parallel to each one of the buses. In this way, routing of thedifferent on-chip components may be facilitated by the logic block set1400.

In some embodiments, each one of the plurality of deactivation switches1312 couple at least one of the plurality of primary logic blocks with aclock node, and each one of the plurality of activation switches 1314may be couple at least one of the plurality of redundant blocks with theclock node allowing to connect\disconnect the clock as a simpleactivation\deactivation mechanism.

Redundant business logic 1310 of redundant logic block set 1400 allowsthe designer to choose, based on area and routing, the blocks that areworth duplication. For example, a chip designer may select larger blocksfor duplication because larger blocks may be more error prone. Thus, achip designer may decide to duplicate large logic blocks. On the otherhand, a designer may prefer to duplicate smaller logic blocks becausethey are easily duplicated without a significant loss of space.Moreover, using the configuration in FIG. 14, a designer may easilychoose to duplicate logic blocks depending on the statistics of errorsper area.

FIG. 15 is a block diagram for an exemplary logic block 1500, consistentwith disclosed embodiments. The logic block may be business logic 1308and/or redundant business logic 1310. In other embodiments, however, theexemplary logic block may describe memory logic 1306 or other componentof memory chip 1300.

Logic block 1500 presents yet another embodiment where the logicredundancy is used within a small processor pipeline. The logic block1500 may include a register 1508, a fetch circuit 1504, decoder 1506,and a write-back circuit 1518. In addition, logic block 1500 may includea computation unit 1510 and a duplicated computing unit 1512. However,in other embodiments, logic block 1500 may include other units that donot comprise a controller pipeline but include sporadic processingelements that comprise a required business logic.

Computation unit 1510 and duplicated computation unit 1512 may include adigital circuit capable of performing digital calculations. For example,computation unit 1510 and duplicated computation unit 1512 may includean arithmetic logic unit (ALU) to perform arithmetic and bitwiseoperations on binary numbers. Alternatively, computation unit 1510 andduplicated computation unit 1512 may include a floating-point unit(FPU), which operates on floating point numbers. In addition, in someembodiments computation unit 1510 and duplicated computation unit 1512may implement data base related functions like min, max, count, andcompare operations, among others.

In some embodiments, as shown in FIG. 15, computation unit 1510 andduplicated computation unit 1512 may be connected to switching circuits1514 and 1516. When activated the switching circuits may enable ordisable the computing units.

In logic block 1500, the duplicated computation unit 1512 may replicatethe computation unit 1510. Moreover, in some embodiments, register 1508,fetch circuit 1504, decoder 1506, and write-back circuit 1518(collectively referred to as the local logic units) may be smaller insize than the computation unit 1510. Because larger elements are moreprone to issues during fabrication, a designer may decide to replicatelarger units (such as computation unit 1510) instead of smaller units(such as the local logic units). Depending on historic yields and errorrates, however, a designed may elect to duplicate local logic unitsadditionally or alternatively to large units (or the entire block). Forexample, computation unit 1510 may be larger, and thus more error prone,than register 1508, fetch circuit 1504, decoder 1506, and write-backcircuit 1518. A designer may choose to duplicate computation unit 1510instead of the other elements in logic block 1500 or the whole block.

Logic block 1500 may include a plurality of local configurationswitches, each one of the plurality of local configuration switchesbeing connected to at least one of the at least one of computation unit1510 or duplicated computation unit 1512. Local configuration switchesmay be configured to disable computation unit 1510 and enable duplicatedcomputation unit 1512 when a fault is detected in the computation unit1510.

FIG. 16 shows block diagrams of exemplary logic blocks connected with abus, consistent with disclosed embodiments. In some embodiments, logicblocks 1602 (which may represent memory logic 1306, business logic 1308,or redundant business logic 1310) may be independent of each other, maybe connected via a bus, and may be activated externally by addressingthem specifically. For example, memory chip 1300 may include many logicblocks, each logic block having an ID number. In other embodiments,however, logic blocks 1602 may represent larger units comprised of aplurality one or more of memory logic 1306, business logic 1308, orredundant business logic 1310.

In some embodiments, each one of logic blocks 1602 may be redundant withthe other logic blocks 1602. This complete redundancy, in which allblocks may operate as primary or redundant blocks, may improvefabrication yields because a designer may disconnect faulty units whilemaintaining functionality of the overall chip. For example, a designermay have the ability to disable logic areas that are prone to errors butmaintain similar computation capabilities because the all duplicateblocks may be connected to the same address and data buses. For example,the initial number of logic blocks 1602 may greater than a targetcapability. Then, disabling some logic blocks 1602 would not affect thetarget capability.

A bus connected to the logic blocks may include address bus 1614,command lines 1616, and data lines 1618. As shown in FIG. 16, each oneof the logic blocks may be connected independently from each line in thebus. In certain embodiments, however, logic blocks 1602 may be connectedin a hierarchical structure to facilitate routing. For instance, eachline in the bus may be connected to a multiplexer that routes the lineto different logic blocks 1602.

In some embodiments, to allow external access without knowing theinternal chip structure, which may change due to enable and disabledunits, each one of the logic blocks may include Fused IDs such as fusedidentification 1604. Fused identification 1604 may include an array ofswitches (like fuses) that determine an ID and may be connected to amanaging circuit. For example, fused identification 1604 may beconnected to address manager 1302. Alternatively, fused identification1604 may be connected to higher memory address units. In theseembodiments, fused identification 1604 may be configurable to for aspecific address. For example, fused identification 1604 may include aprogrammable, non-volatile device that determines a final ID based oninstructions received form a managing circuit.

A distributed processor on a memory chip may be designed with theconfiguration depicted in FIG. 16. A testing procedure executed as BISTat chip wakeup or at factory testing may assign running ID numbers toblocks in the plurality of primary logic blocks (memory logic 1306 andbusiness logic 1308) that pass a testing protocol. A testing proceduremay also assign illegal ID numbers to blocks in the plurality of primarylogic blocks that do not pass the testing protocol. The test proceduremay also assign running ID numbers to blocks in the plurality ofredundant blocks (redundant logic block 1310) that pass the testingprotocol. Because redundant blocks replace failing primary logic blocks,the blocks in the plurality of redundant blocks assigned running IDnumbers may be equal to, or greater than, the blocks in the plurality ofprimary logic blocks assigned illegal ID numbers, thereby disabling theblock. In addition, each one of the plurality of primary logic blocksand each one of the plurality of redundant blocks may include at leastone fused identification 1604. Also, as shown in FIG. 16, the busconnecting logic blocks 1602 may include a command line, a data line,and an address line.

In other embodiments, however, all logic blocks 1602 that are connectedto the bus will start disabled and with no ID number. Tested one by one,each good logic block will get a running ID number, and those logicblocks not working will remain with illegal ID, which would disablethese blocks. In this manner, redundant logic blocks may improve thefabrication yields by replacing blocks that are known to be defectiveduring the testing process.

Address bus 1614 may couple a managing circuit to each one of theplurality of memory banks, each one of the plurality of primary logicblocks, and each one of the plurality of redundant blocks. Theseconnections allow the managing circuit to, upon detection of the faultassociated with a primary logic blocks (such as business logic 1308),assign an invalid address to the one of the plurality of primary logicblocks and assign a valid address to the one of the plurality ofredundant blocks.

For example, as shown in FIG. 16A, illegal IDs are configured to alllogic blocks 1602(a)-(c) (e.g., address 0xFFF). After testing logicblocks 1602(a) and 1602(c) are verified to be functional while logicblock 1602(b) is not functional. In FIG. 16A unshaded logic blocks mayrepresent logic blocks that passed the functionality test successfully,while shaded logic blocks may represent logic blocks that failed thetest for functionality. Then, the test procedure changes the illegal IDsto legal IDs for logic blocks that are functional while leaving theillegal IDs for logic blocks that are not functional. As an example, inFIG. 16A, the address for logic blocks 1602(a) and 1602(c) is changedfrom 0xFFF to 0x001 and 0x002, respectively. In contrast, the addressfor logic block 1602(b) remains the illegal address 0xFFF. In someembodiments, the ID is changed by programming a corresponding fusedidentification 1604.

Different results from the testing of logic blocks 1602 may result in adifferent configuration. For example, as shown in FIG. 16B, addressmanager 1302 may initially assign illegal IDs to all logic blocks 1602(i.e., 0xFFF). The testing results, however, may indicate that bothlogic blocks 1602(a) and 1602(b) are functional. In these cases, testingof logic block 1602(c) may not be necessary because memory chip 1300 mayrequire only two logic blocks. Therefore, to minimize testing resources,logic blocks may be tested only according to the minimum number offunctional logic blocks needed by the product definition of 1300,leaving other logic blocks untested. FIG. 16B also shows unshaded logicblocks, which represent tested logic blocks that passed the test forfunctionality, and shaded logic blocks, which represent untested logicblocks.

In these embodiments, a production tester (external or internal,automatic or manual) or a controller executing a BIST at startup, maychange illegal IDs to running IDs for tested logic blocks that arefunctional while leaving the illegal IDs to untested logic blocks. As anexample, in FIG. 16B, the address for logic blocks 1602(a) and 1602(b)is changed from 0xFFF to 0x001 and 0x002, respectively. In contrast, theaddress for untested logic block 1602(c) remains with the illegaladdress 0xFFF.

FIG. 17 is a block diagram for exemplary units 1702 and 1712 connectedin series, consistent with disclosed embodiments. FIG. 17 may representan entire system or chip. Alternatively, FIG. 17 may represent a blockin a chip containing other functional blocks.

Units 1702 and 1712 may represent complete units that include aplurality of logic blocks such as memory logic 1306 and/or businesslogic 1308. In these embodiments units 1702 and 1712 may also includeelements required to perform operations such as address manager 1302. Inother embodiments, however, units 1702 and 1712 may represent logicunits such as business logic 1308 or redundant business logic 1310.

FIG. 17 presents embodiments in which units 1702 and 1712 may need tocommunicate between themselves. In such cases, units 1702 and 1712 maybe connected in series. However, a non-working unit may break thecontinuity between the logic blocks. Therefore, the connection betweenunits may include a bypass option when a unit needs to be disabled dueto a defect. The bypass option can also be a part of the bypassed unititself.

In FIG. 17 units may be connected in series (e.g., 1702(a)-(c)), and afailing unit (e.g., 1702(b)) may be bypassed when it is defective. Theunits may further be connected in parallel with switching circuits. Forexample, in some embodiments units 1702 and 1712 may be connected withswitching circuits 1722 and 1728, as depicted in FIG. 17. In the exampledepicted in FIG. 17, unit 1702(b) is defective. For example, unit1702(b) does not pass a test for a circuit functionality. Therefore,unit 1702(b) may be disabled using, for example, activation switches1314 (not shown in FIG. 17) and/or switching circuit 1722(b) may beactivated to bypass unit 1702(b) and sustain the connectivity betweenlogic blocks.

Accordingly, when a plurality of primary units are connected in series,each one of the plurality of units may be connected in parallel with aparallel switch. Upon detection of a fault associated with the one ofthe plurality of units, the parallel switch connected to the one of theplurality of units may be activated to connect two of the plurality ofunits.

In other embodiments, as shown in FIG. 17, switching circuits 1728 mayinclude a sampling point or more that would cause a cycle or cyclesdelay maintaining synchronization between different lines of units. Whena unit is disabled, shorting the connection between adjacent logicblocks may generate synchronization errors with other calculations. Forexample, if a task requires data from both A and B lines, and each of Aand B is carried by an independent series of units, disabling a unitwould cause a desynchronization between the lines that would requirefurther data management. To prevent desynchronizations, sample circuits1730 may simulate the delay caused by the disabled unit 1712(b).Nonetheless, in some embodiments, the parallel switch may include ananti-fuse instead of a sampling circuit 1730.

FIG. 18 is a block diagram of exemplary units connected in atwo-dimension array, consistent with disclosed embodiments. FIG. 18 mayrepresent an entire system or chip. Alternatively, FIG. 18 may representa block in a chip containing other functional blocks.

Units 1806 may represent autonomous units that include a plurality oflogic blocks such as memory logic 1306 and/or business logic 1308.However, in other embodiments units 1806 may represent logic units suchas business logic 1308. Where convenient, discussion of FIG. 18 mayrefer to elements identified in FIG. 13 (e.g., memory chip 1300) anddiscussed above.

As shown in FIG. 18, units may be arranged in a two-dimensional array inwhich units 1806 (which may include or represent one or more of memorylogic 1306, business logic 1308, or redundant business logic 1310) areinterconnected via switching boxes 1808 and connection boxes 1810. Inaddition, in order to control the configuration of the two-dimensionalarray, the two-dimensional array may include I/O blocks 1804 in theperiphery of the two-dimensional array.

Connection boxes 1810 may be programmable and reconfigurable devicesthat may respond to signals inputted from the I/O blocks 1804. Forexample, connection boxes may include a plurality of input pins fromunits 1806 and may also be connected to switching boxes 1808.Alternatively, connection boxes 1810 may include a group of switchesconnecting pins of programmable logic cells with routing tracks, whileswitching boxes 1808 may include a group of switches connectingdifferent tracks.

In certain embodiments, connection boxes 1810 and switching boxes 1808may be implemented with configuration switches such as switches 1312 and1314. In such embodiments, connection boxes 1810 and switching boxes1808 may be configured by a production tester or a BIST executed at chipstartup.

In some embodiments, connection boxes 1810 and switching boxes 1808 maybe configured after units 1806 are tested for a circuit functionality.In such embodiments, I/O blocks 1804 may be used to send testing signalsto units 1806. Depending on the test results, I/O blocks 1804 may sendprogramming signals that configure connection boxes 1810 and switchingboxes 1808 in a manner disabling the units 1806 that fail the testingprotocol and enabling units 1806 that pass the testing protocol.

In such embodiments, the plurality of primary logic blocks and theplurality of redundant blocks may be disposed on the substrate in atwo-dimensional grid. Therefore, each one of the plurality of primaryunits 1806 and each one of the plurality of redundant blocks, such asredundant business logic 1310, may be interconnected with switchingboxes 1808, and an input block may be disposed in the periphery of eachline and each column of the two-dimensional grid.

FIG. 19 is a block diagram for exemplary units in a complex connection,consistent with disclosed embodiments. FIG. 19 may represent an entiresystem. Alternatively, FIG. 19 may represent a block in a chipcontaining other functional blocks.

The complex connection of FIG. 19 includes units 1902(a)-(f) andconfiguration switches 1904(a)-(h). Units 1902 may represent autonomousunits that include a plurality of logic blocks such as memory logic 1306and/or business logic 1308. However, in other embodiments units 1902 mayrepresent logic units such as memory logic 1306, business logic 1308, orredundant business logic 1310. Configuration switches 1904 may includeany of deactivation switches 1312 and activation switches 1314.

As shown in FIG. 19, the complex connection may include units 1902 intwo planes. For example, the complex connection may include twoindependent substrates separated in the z-axis. Alternatively, oradditionally, units 1902 may be arranged in two surfaces of a substrate.For example, with the objective to reduce the area of memory chip 1300,substrate 1301 may be arranged in two overlapping surfaces and connectedwith configuration switches 1904 arranged in three dimensions.Configuration switches may include deactivation switches 1312 and/oractivation switches 1314.

A first plane of the substrate may include “main” unit 1902. Theseblocks may be enabled by default. In such embodiments, a second plainmay include “redundant” unit 1902. These units may be disabled bydefault.

In some embodiments, configuration switches 1904 may include anti-fuses.Thus, after testing of units 1902, the blocks may be connected in a tileof functional units by switching certain anti-fuses to “always-on” anddisable selected units 1902, even if they are in a different plane. Inthe example presented in FIG. 19, one of the ‘main’ units (unit 1902(e))is not working. FIG. 19 may represent nonfunctional or untested blocksas shaded blocks while tested or functional blocks may be unshaded.Therefore, configuration switches 1904 are configured so one of thelogic blocks in a different plane (e.g., unit 1902(f)) becomes active.In this way even though one of the main logic blocks was defective, thememory chip is still working by replacing a spare logic unit.

FIG. 19 additionally shows that one of the units 1902 (i.e., 1902(c)) inthe second plane is not tested or enabled because the main logic blocksare functional. For example, in FIG. 19, both main units 1902(a) and1902(d) passed a test for functionality. Thus, units 1902(c) was nottested or enabled. Therefore, FIG. 19 shows the ability to specificallyselect the logic blocks that become active depending on testing results.

In some embodiments, as shown in FIG. 19, not all units 1902 in a firstplain may have a corresponding spare or redundant blocks. However, inother embodiments, all units may be redundant with each other forcomplete redundancy where all units are both primary or redundant. Inaddition, while some implementations may follow the star networktopology depicted in FIG. 19, other implementation may use parallelconnections, serial connections, and/or couple the different elementswith configuration switches in parallel or in series.

FIG. 20 is an exemplary flowchart illustrating a redundant blockenabling process 2000, consistent with disclosed embodiments. Theenabling process 2000 may be implemented for memory chip 1300 andspecially for DRAM memory chips. In some embodiments, process 2000 mayinclude steps of testing each one of a plurality of logic blocks on thesubstrate of the memory chip for at least one circuit functionality,identifying faulty logic blocks in the plurality of primary logic blocksbased on the testing results, testing at least one redundant oradditional logic block on the substrate of the memory chip for the atleast one circuit functionality, disabling the at least one faulty logicblock by applying an external signal to a deactivation switch, andenabling the at least one redundant block by applying the externalsignal to an activation switch, the activation switch being connectedwith the at least one redundant block and being disposed on thesubstrate of the memory chip. The description of FIG. 20 below furtherelaborates on each step of process 2000.

Process 2000 may include testing a plurality of logic blocks (step2002), such as business block 1308 and a plurality of redundant blocks(e.g., redundant business block 1310). The testing may be beforepackaging using, for example, probing stations for on-wafer testing.Step 2000, however, may also be performed after packaging.

The testing in step 2002 may include applying a finite sequence oftesting signals to every logic block in memory chip 1300 or a subset oflogic blocks in memory chip 1300. The testing signals may includerequesting a computation that is expected to yield a 0 or a 1. In otherembodiments, the testing signal may request reading a specific addressin a memory bank or writing in a specific memory bank.

Testing techniques may be implemented to test the response of the logicblocks under iterative processes in step 2002. For example, the test mayinvolve testing logic blocks by transmitting instructions to write datain a memory bank and then verifying the integrity of the written data.In some embodiments, the testing may include repeating the algorithmwith data inversed.

In alternative embodiments, the testing of step 2002 may include runninga model of the logic blocks to generate a target memory image based on aset of testing instructions. Then, the same sequence of instructions maybe executed to the logic blocks in the memory chip, and the results maybe recorded. The residual memory image of the simulation may also becompared to the image taken from the test, and any mismatch may beflagged as a failure.

Alternatively, in step 2002, testing may include shadow modeling, wherea diagnostic is generated but the results are not necessarily predicted.Instead, the test using shadow modeling may be run in parallel on boththe memory chip and a simulation. For example, when the logic blocks inthe memory chip complete an instruction or task, the simulation may besignaled to execute the same instruction. Once the logic blocks in thememory chip finalize the instructions, the two models' architecturalstates may be compared. If there is a mismatch, then a failure isflagged.

In some embodiments, all logic blocks (including, e.g., each one ofmemory logic 1306, business logic 1308, or redundant business logic1310) may be tested in step 2002. In other embodiments, however, onlysubsets of the logic blocks may be tested in different testing rounds.For example, in a first round of testing only memory logic 1306 andassociated blocks may be tested. In a second round, only business logic1308 and associated blocks may be tested. In a third round, depending onthe results of the first two rounds, logic blocks associated withredundant business logic 1310 may be tested.

Process 2000 may continue to step 2004. In step 2004, faulty logicblocks may be identified, and faulty redundant blocks may also beidentified. For example, logic blocks that do not pass the testing ofstep 2002 may be identified as faulty blocks in step 2004. In otherembodiments, however, only certain faulty logic blocks may be initiallyidentified. For example, in some embodiments, only logic blocksassociated with business logic 1308 may be identified, and faultyredundant blocks are only identified if they are required forsubstituting a faulty logic block. In addition, identifying faultyblocks may include writing on a memory bank or a nonvolatile memory theidentification information of the identified faulty blocks.

In step 2006, faulty logic blocks may be disabled. For example, using aconfiguration circuit, the faulty logic blocks may be disabled bydisconnecting them from clock, ground, and/or power nodes.Alternatively, faulty logic blocks may be disabled by configuringconnection boxes in an arrangement that avoids the logic blocks. Yet, inother embodiments, faulty logic blocks may be disabled by receiving anillegal address from address manager 1302.

In step 2008, redundant blocks that duplicate the faulty logic blocksmay be identified. To support the same capabilities of the memory chipseven though some logic blocks have failed, in step 2008, redundantblocks that are available and can duplicate faulty logic blocks may beidentified. For example, if a logic block that performs multiplicationsof vectors is determined to be faulty, in step 2008, an address manager1302 or an on-chip controller may identify an available redundant logicblock that also performs multiplication of vectors.

In step 2010, the redundant blocks identified in step 2008 may beenabled. In contrast to the disable operation of step 2006, in step2010, the identified redundant blocks may be enabled by connecting themto clock, ground, and/or power nodes. Alternatively, identifiedredundant blocks may be enabled by configuring connection boxes in anarrangement that connects the identified redundant blocks. Yet, in otherembodiments, identified redundant blocks may be enabled by receiving arunning address at the test procedure execution time.

FIG. 21 is an exemplary flow chart illustrating an address assignmentprocess 2100, consistent with disclosed embodiments. The addressassignment process 2100 may be implemented for memory chip 1300 andspecially for a DRAM memory chips. As described in relation to FIG. 16,in some embodiments, logic blocks in memory chip 1300 may be connectedto a data bus and have an address identification. Process 2100 describesan address assignment method that disables faulty logic blocks andenables logic blocks that pass a test. The steps described in process2100 will be described as being performed by a production tester or aBIST executed at chip startup; however, other components of memory chip1300 and/or external devices may also perform one or more steps ofprocess 2100.

In step 2102, the tester may disable all logic and redundant blocks byassigning an illegal identification to each logic block at a chip level.

In step 2104, the tester may execute a testing protocol of a logicblock. For example, the tester may run testing methods described in step2002 for one or more of the logic blocks in memory chip 1300.

In step 2106, depending on the results of the test in step 2104, thetester may determine whether the logic block is defective. If the logicblock is not defective (step 2106: no), address manager may assign arunning ID to the tested logic block in step 2108. If the logic block isdefective (step 2106: yes), address manager 1302 may leave the illegalID for the defective logic block in step 2110.

In step 2112, address manager 1302 may select a redundant logic blockthat replicates the defective logic block. In some embodiments, theredundant logic block that replicates the defective logic block may havethe same components and connections to the defective logic blocks. Inother embodiments, however, the redundant logic block may have differentcomponents and/or connections to the defective logic blocks but be ableto perform an equivalent operation. For example, if the defective logicblock is designed to perform multiplication of vectors, the selectedredundant logic block would also be capable of performing multiplicationof vectors, even if it does not have the same architecture as thedefective unit.

In step 2114, address manager 1302 may test the redundant block. Forinstance, the tester may apply the testing techniques applied in step2104 to the identified redundant block.

In step 2116, based on the results of testing in step 2114, the testermay determine whether the redundant block is defective. In step 2118, ifthe redundant block is not defective (step 2116: no), the tester mayassign a running ID to the identified redundant block. In someembodiments, process 2100 may return to step 2104 after step 2118,creating an iteration loop to test all logic blocks in the memory chip.

If the tester determines the redundant block is defective (step 2116:yes), in step 2120, the tester may determine if additional redundantblocks are available. For example, the tester may query a memory bankwith information regarding available redundant logic blocks. Ifredundant logic blocks are available (step 2120: yes), the tester mayreturn to step 2112 and identify a new redundant logic block replicatingthe defective logic block. If redundant logic blocks are not available(step 2120: no), in step 2122, the tester may generate an error signal.The error signal may include information of the defective logic blockand the defective redundant block.

Coupled Memory Banks

The presently disclosed embodiments also include a distributedhigh-performance processor. The processor may include a memorycontroller that interfaces memory banks and processing units. Theprocessor may be configurable to expedite delivery of data to theprocessing units for calculations. For example, if a processing unitrequires two data instances to perform a task, the memory controller maybe configured so communication lines independently provide access to theinformation from two data instances. The disclosed memory architectureseeks to minimize hardware requirements that are associated with complexcache memory and complex register files schemes. Normally, processorchips include cache hierarchies that allow cores to work directly withregisters. However, the cache operations require significant die areaand consume additional power. The disclosed memory architecture avoidsthe use of a cache hierarchy by adding logic components in the memory.

The disclosed architecture also enables strategic (or even optimized)placement of data in memory banks. Even if the memory banks have asingle port and high latency, the disclosed memory architecture mayenable high performance and avoid memory accessing bottlenecks bystrategically positioning data in different blocks of memory banks. Withthe goal of providing a continuous stream of data to the processingunits, a compilation optimization step may determine how data should bestored in memory banks for specific or generic tasks. Then, the memorycontroller, which interfaces processing units and memory banks, may beconfigured to grant access to specific processing units when theyrequire data to perform operations.

The configuration of the memory chip may be performed by a processingunit (e.g., a configuration manager) or an external interface. Theconfiguration may be also written by a compiler or other SW tool. Inaddition, the configuration of the memory controller may be based on theavailable ports in the memory banks and the organization of data in thememory banks. Accordingly, the disclosed architecture may provideprocessing units with a constant flow of data or simultaneousinformation from different memory blocks. In this way, computation taskswithin the memory may be quickly processed by avoiding latencybottlenecks or cache memory requirements.

Moreover, data stored in the memory chip may be arranged based oncompilation optimization steps. The compilation may allow for buildingof processing routines in which the processor efficiently assigns tasksto processing units without memory latency associated delays. Thecompilation may be performed by a compiler and transmitted to a hostconnected to an external interface in the substrate. Normally, highlatency for certain access patterns and/or low numbers of ports wouldresult in data bottlenecks for processing units requiring the data. Thedisclosed compilation, however, may position data in memory banks in away that enables processing units to continuously receive data even withdisadvantageous memory types.

Furthermore, in some embodiments, a configuration manager may signalrequired processing units based on computations that are required by atask. Different processing units or logic blocks in the chip may havespecialized hardware or architectures for different tasks. Therefore,depending on the task that will be performed, a processing unit, or agroup of processing units, may be selected to perform the task. Thememory controller on the substrate may be configurable to route data, orgrant access, according to the selection of processing subunits toimprove data transfer rates. For example, based on the compilationoptimization and the memory architecture, processing units may begranted access to memory banks when they are required to perform a task.

Moreover, the chip architecture may include on-chip components thatfacilitate transfer of data by reducing the time required to access datain the memory banks. Therefore, the present disclosure describes chiparchitecture(s), along with a compilation optimization step, for ahigh-performance processor capable of performing specific or generictasks using simple memory instances. The memory instances may have highlatency in random access and/or low number of ports, such as those usedin a DRAM device or other memory-oriented technologies, but thedisclosed architecture may overcome these shortcomings by enabling acontinuous (or nearly continuous) flow of data from memory banks toprocessing units.

In this application, simultaneous communication may refer tocommunication within a clock cycle. Alternatively, simultaneouscommunication may refer to sending information within a predetermineamount of time. For example, simultaneous communication may refer tocommunication within a few nanoseconds.

FIG. 22 provides block diagrams for exemplary processing devices,consistent with disclosed embodiments. FIG. 22A shows a first embodimentof a processing device 2200 in which a memory controller 2210 connects afirst memory block 2202 and a second memory block 2204 usingmultiplexers. Memory controller 2210 may also connect at least aconfiguration manager 2212, a logic block 2214, and multipleaccelerators 2216(a)-(n). FIG. 22B shows a second embodiment ofprocessing device 2200 in which memory controller 2210 connects memoryblocks 2202 and 2204 using a bus that connects memory controller 2210with at least a configuration manager 2212, a logic block 2214, andmultiple accelerators 2216(a)-(n). In addition, host 2230 may beexternal and connected to processing device 2200 through, for example,an external interface.

Memory blocks 2202 and 2204 may include a DRAM mats or group of mats,DRAM banks, MRAM\PRAM\RERAM\SRAM units, Flash mats, or other memorytechnologies. Memory blocks 2202 and 2204 may alternatively includenon-volatile memories, a flash memory device, a Resistive Random AccessMemory (ReRAM) device, or a Magnetoresistive Random Access Memory (MRAM)device.

Memory blocks 2202 and 2204 may additionally include a plurality ofmemory cells arranged in rows and columns between a plurality of wordlines (not shown) and a plurality of bit lines (not shown). The gates ofeach row of memory cells may be connected to a respective one of theplurality of word lines. Each column of memory cells may be connected toa respective one of the plurality of bit lines.

In other embodiments, a memory area (including memory blocks 2202 and2204) is built from simple memory instances. In this application, theterm “memory instance” may be used interchangeably with the term “memoryblock.” The memory instances (or blocks) may have poor characteristics.For example, the memories may be only one port memories and may havehigh random-access latency. Alternatively, or additionally, the memoriesmay be inaccessible during column and line changes and face data accessproblems related to, for example, capacity charging and/or circuitrysetups. Nonetheless, the architecture presented in FIG. 22 stillfacilitates parallel processing in the memory device by allowingdedicated connections between memory instances and processing units andarranging the data in a certain manner that takes the characteristics ofthe blocks into account.

In some device architectures, memory instances may include severalports, facilitating the parallel operations. Nonetheless, in suchembodiments, the chip may still achieve an improved performance whendata is compiled and organized based on the chip architecture. Forexample, a compiler may improve the efficiency of access in the memoryarea by providing instructions and organizing data placement, so it canbe readily access even using one-port memories.

Furthermore, memory blocks 2202 and 2204 may be multiple types formemory in a single chip. For example, memory blocks 2202 and 2204 may beeFlash and eDRAM. Also, memory blocks may include DRAM with instances ofROM.

Memory controller 2210 may include a logic circuit to handle the memoryaccess and return the results to the rest of the modules. For example,memory controller 2210 may include an address manager and selectiondevices, such as multiplexers, to route data between the memory blocksand processing units or grant access to the memory blocks.Alternatively, Memory controller 2210 may include double data rate (DDR)memory controllers used to drive DDR SDRAM, where data is transferred onboth rising and falling edges of the system's memory clock.

In addition, memory controller 2210 may constitute Dual Channel memorycontrollers. The incorporation of dual channel memory may facilitatecontrol of parallel access lines by memory controller 2210. The parallelaccess lines may be configured to have identical lengths to facilitatesynchronization of data when multiple lines are used in conjunction.Alternatively, or additionally, the parallel access lines may allowaccess of multiple memory ports of the memory banks.

In some embodiments processing device 2200 may include one or more muxesthat may be connected to processing units. The processing units mayinclude configuration manager 2212, logic block 2214, and accelerators2216, which may be connected directly to the mux. Also, memorycontroller 2210 may include at least one data input from a plurality ofmemory banks or blocks 2202 and 2204 and at least one data outputconnected to each one of the plurality of processing units. With thisconfiguration, memory controller 2210 may simultaneously receive datafrom memory banks or memory blocks 2202 and 2204 via the two datainputs, and simultaneously transmits data received via to the at leastone selected processing unit via the two data outputs. In someembodiments, however, the at least one data input and at least one dataoutput may be implemented in a single port allowing only read or writeoperations. In such embodiments, the single port may be implemented as adata bus including data, address, and command lines.

Memory controller 2210 may be connected to each one of the plurality ofmemory blocks 2202 and 2204, and may also connect to processing unitsvia, for example, a selection switch. Also processing units on thesubstrate, including configuration manager 2212, logic block 2214, andaccelerators 2216, may be independently connected to memory controller2210. In some embodiments, configuration manager 2212 may receive anindication of a task to be performed and, in response, configure memorycontroller 2210, accelerators 2216, and/or logic blocks 2214 accordingto a configuration stored in memory or supplied externally.Alternatively, memory controller 2210 may be configured by an externalinterface. The task may require at least one computation that may beused to select at least one selected processing unit from the pluralityof processing units. Alternatively, or additionally, the selection maybe based at least in part upon a capability of the selected processingunit for performing the at least one computation. In response, memorycontroller 2210 may grant access to the memory banks, or route databetween the at least one selected processing unit and at least twomemory banks, using dedicated buses and/or in a pipelined memory access.

In some embodiments, first memory block 2202 of at least two memoryblocks may be arranged on a first side of the plurality of processingunits; and second memory bank 2204 of the at least two memory banks maybe arranged on a second side of the plurality of processing unitsopposite to the first side. Further, a selected processing unit toperform the task, for instance accelerator 2216(n), may be configured toaccess second memory bank 2204 during a clock cycle in which acommunication line is opened to the first memory bank or first memoryblock 2202. Alternatively, the selected processing unit may beconfigured to transfer data to second memory block 2204 during a clockcycle in which a communication line is opened to first memory block2202.

In some embodiments, memory controller 2210 may be implemented as anindependent element, as shown in FIG. 22. In other embodiments, however,memory controller 2210 may be embedded in the memory area or may bedisposed along accelerators 2216(a)-(n).

A processing area in processing device 2200 may include configurationmanager 2212, logic block 2214, and accelerators 2216(a)-(n).Accelerators 2216 may include multiple processing circuits withpre-defined functions and may be defined by a specific application. Forexample, an accelerator may be a vector multiply accumulate (MAC) unitor a Direct Memory Access (DMA) unit handling memory moving betweenmodules. Accelerators 2216 may also be able to calculate their ownaddress and request the data from memory controller 2210 or write datato it. For example, configuration manager 2212 may signal at least oneof accelerators 2216 that he can access the memory bank. Thenaccelerators 2216 may configure memory controller 2210 to route data orgrant access to themselves. In addition, accelerators 2216 may includeat least one arithmetic logic unit, at least one vector handling logicunit, at least one string compare logic unit, at least one register, andat least one direct memory access.

Configuration manager 2212 may include digital processing circuits toconfigure accelerators 2216 and instructs execution of tasks. Forexample, configuration manager 2212 may be connected to memorycontroller 2210 and each one of the plurality of accelerators 2216.Configuration manager 2212 may have its own dedicated memory to hold theconfigurations of accelerators 2216. Configuration manager 2212 may usethe memory banks to fetch commands and configurations via memorycontroller 2210. Alternatively, configuration manager 2212 may beprogrammed through an external interface. In certain embodiments,configuration manager 2212 may be implemented with an on-chip reducedinstruction set computer (RISC) or an on-chip complex CPU with its owncache hierarchy. In some embodiments, configuration manager 2212 mayalso be omitted and the accelerators can be configured through anexternal interface.

Processing device 2200 may also include an external interface (notshown). The external interface allows access to the memory from an upperlevel, such a memory bank controller which receives the command fromexternal host 2230 or on-chip main processor or access to the memoryfrom external host 2230 or on-chip main processor. The externalinterface may allow programming of the configuration manager 2212 andthe accelerators 2216 by writing configurations or code to the memoryvia memory controller 2210 to be used later by configuration manager2212 or the units 2214 and 2216 themselves. The external interface,however, may also directly program processing units without being routedthrough memory controller 2210. In case configuration manager 2212 is amicrocontroller, configuration manager 2212 may allow loading of codefrom a main memory to the controller local memory via the externalinterface. Memory controller 2210 may be configured to interrupt thetask in response to receiving a request from the external interface.

The external interface may include multiple connectors associated withlogic circuits that provide a glue-less interface to a variety ofelements on the processing device. The external interface may include:Data I/O Inputs for data reads and output for data writes; Externaladdress outputs; External CE0 chip select pins; Active-low chipselectors; Byte enable pins; a pin for wait states on the memory cycle;a Write enable pin; an Output enable-active pin; and read-write enablepin. Therefore, the external interface has the required inputs andoutputs to control processes and obtain information from the processingdevice. For example, the external interface may conform to JEDEC DDRstandards. Alternatively, or additionally, external interface mayconform to other standards such as SPROSPI or UART.

In some embodiments, the external interface may be disposed on the chipsubstrate and may be connected external host 2230. The external host maygain access to memory blocks 2202 and 2204, memory controller 2210, andprocessing units via the external interface. Alternatively, oradditionally, external host 2230 may read and write to the memory or maysignal configuration manager 2212, through read and write commands, toperform operations such as starting a process and/or stopping a process.In addition, external host 2230 may configure the accelerators 2216directly. In some embodiments, external host 2230 be able to performread/write operations directly on memory blocks 2202 and 2204.

In some embodiments, configuration manager 2212 and accelerators 2216may be configured to connect the device area with the memory area usingdirect buses depending on the target task. For example, a subset ofaccelerators 2216 may connect with memory instances 2204 when the subsetof accelerators has the capability to perform computations required toexecute the task. By doing such a separation, it is possible to assurethat dedicated accelerators get the bandwidth (BW) needed to memoryblocks 2202 and 2204. Moreover, this configuration with dedicated busesmay allow splitting a large memory to smaller instances or blocksbecause connecting memory instances to memory controller 2210 allowsquick access to data in different memories even with high row latencytime. To achieve the parallelization of connection, memory controller2210 may be connected to each of the memory instances with data,address, and/or control buses.

The above-discussed inclusion of memory controller 2210 may eliminatethe requirement of a cache hierarchy or complex register file in theprocessing device. Although the cache hierarchy can be added to giveadded capabilities, the architecture in processing device processingdevice 2200 may allow a designer to add enough memory blocks orinstances based on the processing operations and manage the instancesaccordingly without a cache hierarchy. For example, the architecture inprocessing device processing device 2200 may eliminate requirements of acache hierarchy by implementing a pipelined memory access. In thepipelined memory access, processing units may receive a sustaining flowof data in every cycle certain data lines may be opened (or activated)while other data lines receive or transmit data. The sustained flow ofdata using independent communication lines may allow an improvedexecution speed and minimum latency due to line changes.

Moreover, the disclosed architecture in FIG. 22 enables a pipelinedmemory access it may be possible to organize data in a low number ofmemory blocks and save power losses caused by line switching. Forexample, in some embodiments, a compiler may communicate host 2230 theorganization of, or a method to organize, data in memory banks tofacilitate access to data during a given task. Then, configurationmanager 2212 may define which memory banks, and in some cases whichports of the memory banks, may be accessed by the accelerators. Thissynchronization between the location of data in memory banks and theaccess method to data, improves computing tasks by feeding data to theaccelerators with minimum latency. For example, in embodiments in whichconfiguration manager 2212 includes a RISC\CPU, the method may beimplemented in offline software (SW) and then the configuration manager2212 may be programmed to execute the method. The method may bedeveloped in any language executable by RISC/CPU computers and may beexecuted on any platform. The inputs of the method may includeconfiguration of the memories behind memory controller and the dataitself along with the pattern of memory accesses. In addition, themethod may be implemented in a language or machine language specific tothe embodiment and may also be just a series of configuration values inbinary or text.

As discussed above, in some embodiments, a compiler may provideinstructions to host 2230 for organizing data in memory blocks 2202 and2204 in preparation of a pipelined memory access. The pipelined memoryaccess may generally include steps of: receiving a plurality ofaddresses of a plurality of memory banks or memory blocks 2202 and 2204;accessing the plurality of memory banks according to the receivedaddresses using independent data lines; supplying data from a firstaddress through a first communication line to at least one of theplurality of processing units and opening a second communication line toa second address, the first address being in a first memory bank of theplurality of memory banks, the second address being in second memorybank 2204 of the plurality of memory banks; and supplying data from thesecond address through the second communication line to the at least oneof the plurality of processing units and opening a third communicationline to a third address in the first memory bank in the first linewithin a second clock cycle. In some embodiments, the pipelined memoryaccess may be executed with two memory blocks being connected to asingle port. In such embodiments, memory controller 2210 may hide thetwo memory blocks behind a single port but transmit data to theprocessing units with the pipelined memory access approach.

In some embodiments, a compiler can run on host 2230 before executing atask. In such embodiments, the compiler may be able to determine aconfiguration of data flow based on the architecture of the memorydevice since the configuration would be known to the compiler.

In other embodiments, if the configuration of memory blocks 2204 and2202 is unknown at offline time, the pipelined method can run on host2230 which may arrange data in memory blocks before startingcalculations. For example, host 2230 may directly write data in memoryblocks 2204 and 2202. In such embodiments, processing units, such asconfiguration manager 2212 and memory controller 2210 may not haveinformation regarding required hardware until run time. Then, it may benecessary to delay the selection of an accelerator 2216 until a taskstarts running. In these situations, the processing units or memorycontroller 2210 may randomly select an accelerator 2216 and create atest data access pattern, which may be modified as the task is executed.

Nonetheless, when the task is known in advance, a compiler may organizedata and instructions in memory banks for host 2230 to provide to aprocessing unit, such as configuration manager 2212, to set signalconnections that minimize access latency. For example, in some cases nwords may be needed at the same time by accelerators 2216. However, eachmemory instance supports retrieving only m words at a time, where “m”and “n” are integers and m<n. Thus, the compiler may place the neededdata across different memory instances or blocks facilitating dataaccess. Also, to avoid line miss latencies, a host may split data indifferent lines of different memory instances if processing device 2200includes multiple memory instances. The division of data may allowaccessing the next line of data in the next instance while still usingdata from the current instance.

For example, accelerator 2216(a) may be configured to multiply twovectors. Each one of the vectors may be stored in independent memoryblocks, such as memory blocks 2202 and 2204, and each vector may includemultiple words. Therefore, to complete a task requiring a multiplicationby accelerator 2216(a), it may be necessary to access the two memoryblocks and retrieve multiple words. However, in some embodiments, memoryblocks only allow access of one word per clock cycle. For instance,memory blocks may have a single port. In these cases, to expedite datatransmittal during an operation, a compiler may organize the wordscomposing vectors in different memory blocks allowing parallel and/orsimultaneous reading of the words. In these situations, a compiler maystore words in memory blocks that have a dedicated line. For instance,if each vector includes two words and memory controller has directaccess to four memory blocks, a compiler may arrange data in four memoryblocks, each one transmitting a word and expediting data delivery.Moreover, in embodiments when memory controller 2210 may have more thana single connection to each memory block, the compiler may instructconfiguration manager 2212 (or other processing unit) to access portsspecific ports. In this way, processing device 2200 may perform apipelined memory access, continuously providing data to processing unitsby simultaneously loading words in some lines and transmitting data inother lines. Thus, this pipelined memory access avoid may avoid latencyissues.

FIG. 23 is a block diagram of an exemplary processing device 2300,consistent with disclosed embodiments. The block diagram shows asimplified processing device 2300 displaying a single accelerator in theform of MAC Unit 2302, configuration manager 2304 (equivalent or similarto configuration manager 2212), memory controller 2306 (equivalent orsimilar to memory controller 2210), and a plurality of memory blocks2308(a)-(d).

In some embodiments, MAC unit 2302 may be a specific accelerator forprocessing a particular task. By way of example, the processing device2300 may be tasked with 2D-convolutions. Then, configuration manager2304 can signal an accelerator that has the appropriate hardware toperform calculations associated with the task. For instance, MAC unit2302 may have four internal incrementing counters (logical adders andregisters to manage the four loops needed by a convulsion calculation)and a multiply accumulate unit. Configuration manager 2304 may signalMAC unit 2302 to process incoming data and execute the task.Configuration manager 2304 may transmit an indication to MAC unit 2302to execute the task. In these situations, MAC unit 2302 may iterate overcalculated addresses, multiply the numbers, and accumulate them to aninternal register.

In some embodiments, configuration manager 2304 may configure theaccelerators while memory controller 2306 grants access to blocks 2308and MAC unit 2302 using dedicated buses. In other embodiments, however,memory controller 2306 can directly configure the accelerators based oninstructions received from configuration manger 2304 or an externalinterface. Alternatively, or additionally, configuration manager 2304can pre-load a few configurations and allow the accelerator toiteratively run on different addresses with different sizes. In suchembodiments, configuration manager 2304 may include a cache memory thatstores a command before it is transmitted to at least one of theplurality of processing units, such as accelerators 2216. However, inother embodiments configuration manager 2304 may not include a cache.

In some embodiments, configuration manager 2304 or memory controller2306 may receive addresses that need to be accessed for a task.Configuration manager 2304 or memory controller 2306 may check aregister to determine whether the address is already in a loaded line toone of memory blocks 2308. If so, memory controller 2306 may read theword from memory block 2308 and pass it to the MAC unit 2302. If theaddress is not in a loaded line, configuration manager 2304 may requestmemory controller 2306 may load the line and signal MAC unit 2302 todelay until it is retrieved.

In some embodiments, as shown in FIG. 23, memory controller 2306 mayinclude two inputs form two independent addresses. But if more than twoaddresses should be accessed simultaneously, and these addresses are ina single memory block (for example it is only in of memory blocks2308(a)), memory controller 2306 or configuration manager 2304 may raisean exception. Alternatively, configuration manager 2304 may returninvalid data signal when the two addresses can only be access through asingle line. In other embodiments, the unit may delay the processexecution until it is possible to retrieve all needed data. This maydiminish the overall performance. Nonetheless, a compiler may be able tofind a configuration and data placement that would prevent delays.

In some embodiments, a compiler may create a configuration orinstruction set for processing device 2300 that may configureconfiguration manager 2304 and memory controller 2306 and accelerator2302 to handle situations in which multiple addresses need to beaccessed from a single memory block but the memory block has one port.For instance, a compiler may re-arrange data in memory blocks 2308 suchthat processing units may access multiple lines in memory blocks 2308.

In addition, memory controller 2306 may also work simultaneously on morethan one input at the same time. For example, memory controller 2306 mayallow accessing one of memory blocks 2308 through one port and supplyingthe data while receiving a request from a different memory block inanother input. Therefore, this operation may result in and accelerator2216 tasked with the exemplary 2D-convolutions receiving data fromdedicated lines of communication with the pertinent memory blocks.

Additionally, or alternatively, memory controller 2306 or a logic blockmay hold refresh counters for every memory block 2308 and handle therefresh of all lines. Having such a counter allows memory controller2306 to slip in the refresh cycles between dead access times from thedevices.

Furthermore, memory controller 2306 may be configurable to perform thepipelined memory access, receiving addresses and opening lines in memoryblocks before supplying the data. The pipelined memory access mayprovide data to processing units without interruption or delayed clockcycles. For example, while memory controller 2306 or one of the logicblocks access data with the right line in FIG. 23, it may betransmitting data in the left line. These methods will be explained ingreater detail in connection to FIG. 26.

In response to the required data, processing device 2300 may usemultiplexors and/or other switching devices to choose which device getsserviced to perform a given task. For example, configuration manager2304 may configure multiplexers so at least two data lines reach the MACunit 2302. In this way, a task requiring data from multiple addresses,such as 2D-convolutions, may be performed faster because the vectors orwords requiring multiplication during convolution can reach theprocessing unit simultaneously, in a single clock. This datatransferring method may allow the processing units, such as accelerators2216, to quickly output a result.

In some embodiments, configuration manager 2304 may be configurable toexecute processes based on priority of tasks. For example, configurationmanager 2304 can be configured to let a running process finish withoutany interruptions. In that case, configuration manger 2304 may providean instruction or configurations of a task to accelerators 2216, letthem run uninterrupted, and switch multiplexers only when the task isfinished. However, in other embodiments, configuration manager 2304 mayinterrupt a task and reconfigure data routing when it receives apriority task, such a request from an external interface. Nevertheless,with enough memory blocks 2308, memory controller 2306 may beconfigurable to route data, or grant access, to processing units withdedicated lines that do not have to be changed until a task iscompleted. Moreover, in some embodiments, all devices may be connectedby buses to the entries of configuration manager 2304, and the devicesmay manage access between themselves and the buses (e.g., using the samelogic as a multiplexer). Therefore, memory controller 2306 may bedirectly connected to a number of memory instances or memory blocks.

Alternatively, memory controller 2306 may be connected directly tomemory sub-instances. In some embodiments, each memory instance or blockcan be built from sub-instances (for example, DRAM may be built frommats with independent data lines arranged in multiple sub-blocks).Further, the instances may include at least one of DRAM mats, DRAM,banks, flash mats, or SRAM mats or any other type of memory. Then,memory controller 2306 may include dedicated lines to addresssub-instances directly to minimize latency during a pipelined memoryaccess.

In some embodiments, memory controller 2306 may also hold the logicneeded for a specific memory instance (such as row\col decoders, refreshlogic, etc.) and memory blocks 2308 may handle its own logic. Therefore,memory blocks 2308 may get an address and generate commands forreturn\write data.

FIG. 24 depicts exemplary memory configuration diagrams, consistent withdisclosed embodiments. In some embodiments, a compiler generating codeor configuration for processing device 2200 may perform a method toconfigure loading from memory blocks 2202 and 2204 by pre-arranging datain each block. For example, a compiler may prearrange data so each wordrequired for a task is correlated to a line of memory instance or memoryblock(s). But for tasks that require more memory blocks than the oneavailable in processing device 2200, a compiler may implement methods offitting data in more than one memory location of each memory block. Thecompiler may also store data in sequence and evaluate the latency ofeach memory block to avoid line miss latency. In some embodiments, thehost may be part of a processing unit, such as configuration manger2212, but in other embodiments the compiler host may be connected toprocessing device 2200 via an external interface. In such embodiments,the host may run compiling functions, such as the ones described for thecompiler.

In some embodiments, configuration manager 2212 may be a CPU or a microcontroller (uC). In such embodiments, configuration manager 2212 mayhave to access the memory to fetch commands or instructions placed inthe memory. A specific compiler may generate the code and place it inthe memory in a manner that allows for consecutive commands to be storedin the same memory line and across a number of memory banks to allow forthe pipelined memory access also on the fetched command. In theseembodiments, configuration manager 2212 and memory controller 2210 maybe capable of avoiding row latency in linear execution by facilitatingthe pipelined memory access.

The previous case of linear execution of a program described a methodfor a compiler to recognize and place the instructions to allow forpipelined memory execution. However other software structures may bemore complex and would require the compiler to recognize them and actaccordingly. For example, in case a task requires loops and branches, acompiler may place all the loop code inside a single line so that thesingle line can be looped without line opening latency. Then, memorycontroller 2210 may not need to change lines during an execution.

In some embodiments, configuration manager 2212 may include internalcaching or small memory. The internal caching may store commands thatare executed by configuration manager 2212 to handle branches and loops.For example, commands in internal caching memory may includeinstructions to configure accelerators for accessing memory blocks.

FIG. 25 is an exemplary flowchart illustrating a possible memoryconfiguration process 2500, consistent with disclosed embodiments. Whereconvenient in describing memory configuration process 2500, referencemay be made to the identifiers of elements depicted in FIG. 22 anddescribed above. In some embodiments, process 2500 may be executed by acompiler that provides instructions to a host connected through anexternal interface. In other embodiments, process 2500 may be executedby components of processing device 2200, such as configuration manager2212.

In general, process 2500 may include determining a number of wordsrequired simultaneously to perform the task; determining a number ofwords that can be accessed simultaneously from each one of the pluralityof memory banks; and dividing the number of words requiredsimultaneously between multiple memory banks when the number of wordsrequired simultaneously is greater than the number of words that can beaccessed simultaneously. Moreover, dividing the number of words requiredsimultaneously may include executing a cyclic organization of words andsequentially assigning one word per memory bank.

More specifically, process 2500 may begin with step 2502, in which acompiler may receive a task specification. The specification includesrequired computations and/or a priority level.

In step 2504, a compiler may identify an accelerator, or group ofaccelerators, that may perform the task. Alternatively, the compiler maygenerate instructions so the processing units, such as configurationmanager 2212, may identify an accelerator to perform the task. Forexample, using the required computation configuration manger 2212 mayidentify accelerators in the group of accelerators 2216 that may processthe task.

In step 2506, the compiler may determine a number of words that needs tobe simultaneously accessed to execute the task. For example, themultiplication of two vectors requires access to at least two vectors,and the compiler may therefore determine that vector words must besimultaneously accessed to perform the operation.

In step 2508, the compiler may determine a number of cycles necessary toexecute the task. For example, if the task requires a convolutionoperation of four by-products, the compiler may determine that at least4 cycles will be necessary to perform the task.

In step 2510, the compiler may place words that are needed to beaccessed simultaneously in different memory banks. In that way, memorycontroller 2210 may be configured to open lines to different memoryinstances and access the required memory blocks within a clock cycle,without any required cached data.

In step 2512, the compiler place words that are accessed sequentially inthe same memory banks. For example, in the case that four cycles ofoperations are required, the compiler may generate instructions to writeneeded words in sequential cycles in a single memory block to avoidchanging lines between different memory blocks during execution.

In step 2514, compiler generate instructions for programing processingunits, such as configuration manager 2212. The instructions may specifyconditions to operate a switching device (such as a multiplexor) orconfigure a data bus. With such instructions, configuration manager 2212may configure memory controller 2210 to route data from, or grant accessto, memory blocks to processing units using dedicated lines ofcommunication according to a task.

FIG. 26 is an exemplary flowchart illustrating a memory read process2600, consistent with disclosed embodiments. Where convenient indescribing memory read process 2600, reference may be made to theidentifiers of elements depicted in FIG. 22 and described above. In someembodiments, as described below, process 2600 may be implemented bymemory controller 2210. In other embodiments, however, process 2600 maybe implemented by other elements in the processing device 2200, such asconfiguration manager 2212.

In step 2602, memory controller 2210, configuration manager 2212, orother processing units may receive an indication to route data from, orgrant access to, a memory bank. The request may specify an address and amemory block.

In some embodiments, the request may be received via a data busspecifying a read command in line 2218 and address in line 2220. Inother embodiments, the request may be received via demultiplexersconnected to memory controller 2210.

In step 2604, configuration manager 2212, a host, or other processingunits, may query an internal register. The internal register may includeinformation regarding opened lines to memory banks, opened addresses,opened memory blocks, and/or upcoming tasks. Based on the information inthe internal register, it may be determined whether there are linesopened to the memory bank and/or whether the memory block received therequest in step 2602. Alternatively, or additionally, memory controller2210 may directly query the internal register.

If the internal register indicates that the memory bank is not loaded inan opened line (step 2606: no), process 2600 may continue to step 2616and a line may be loaded to a memory bank associated with the receivedaddress. In addition, memory controller 2210 or a processing unit, suchas configuration manager 2212, may signal a delay to the elementrequesting information from the memory address in step 2616. Forexample, if accelerator 2216 is requesting the memory information thatis located an already occupied memory block, memory controller 2210 maysend a delay signal to the accelerator in step 2618. In step 2620,configuration manager 2212 or memory controller 2210 may update theinternal register to indicate a line has opened to a new memory bank ora new memory block.

If the internal register indicates that the memory bank is loaded in anopened line (step 2606: yes), process 2600 may continue to step 2608. Instep 2608, it may be determined whether the line loaded the memory bankis being used for a different address. If the line is being used for adifferent address (step 2608: yes), it would indicate that there are twoinstances in a single block and, therefore, they cannot be accessedsimultaneously. Thus, an error or exemption signal may be sent to theelement requesting information from the memory address in step 2616.But, if the line is not being used for a different address (step 2608:no), a line may be opened for the address and retrieve data from thetarget memory bank and continue to step 2614 to transmit data to the tothe element requesting information from the memory address.

With process 2600, processing device 2200 has the ability to establishdirect connections between processing units and the memory blocks ormemory instances that contain the required information to perform atask. This organization of data would enable reading information fromorganized vectors in different memory instances, as well as allow theretrieval of information simultaneously from different memory blockswhen a device requests a plurality of these addresses.

FIG. 27 is an exemplary flowchart illustrating an execution process2700, consistent with disclosed embodiments. Where convenient indescribing execution process 2700, reference may be made to theidentifiers of elements depicted in FIG. 22 and described above.

In step 2702, a compiler or a local unit, such as configuration manager2212, may receive an indication of a task that needs to be performed.The task may include a single operation (e.g., multiplication) or a morecomplex operation (e.g., convolution between matrixes). The task mayalso indicate a required computation.

In step 2704, the compiler or configuration manager 2212 may determine anumber of words that is required simultaneously to perform the task. Forexample, configuration a compiler may determine two words are requiredsimultaneously to perform a multiplication between vectors. In anotherexample, a 2D convolution task, configuration manager 2212 may determinethat “n” times “m” words are required for a convolution betweenmatrices, where “n” and “m” are the matrices dimensions. Moreover, instep 2704, configuration manager 2212 may also determine a number ofcycles necessary to perform the task.

In step 2706, depending on the determinations in step 2704, a compilermay write words that need to be accessed simultaneously in a pluralityof memory banks disposed on the substrate. For instance, when a number anumber of words that can be accessed simultaneously from one of theplurality of memory banks is lower than the number of words that arerequired simultaneously, a compiler may organize data in multiple memorybanks to facilitate access to the different required words within aclock. Moreover, when configuration manager 2212 or the compilerdetermine a number of cycles is necessary to perform the task, thecompiler may write words that are needed in sequential cycles in asingle memory bank of the plurality of memory banks to prevent switchingof lines between memory banks.

In step 2708, memory controller 2210 may be configured to read or grantaccess to at least one first word from a first memory bank from theplurality of memory banks or blocks using a first memory line.

In step 2170, a processing unit, for example one of accelerators 2216,may process the task using the at least one first word.

In step 2712, memory controller 2210 may be configured to open a secondmemory line in a second memory bank. For example, based on the tasks andusing the pipelined memory access approach, memory controller 2210 maybe configured to open a second memory line in a second memory blockwhere information required for the tasks was written in step 2706. Insome embodiments, the second memory line may be opened when the task instep 2170 is about to be completed. For example, if a task requires 100clocks, the second memory line may be opened in the 90th clock.

In some embodiments, steps 2708-2712 may be executed within one lineaccess cycle.

In step 2714, memory controller 2210 may be configured to grant accessto data from at least one second word from the second memory bank usingthe second memory line opened in step 2710.

In step 2176, a processing unit, for example one of accelerators 2216,may process the task using the at least second word.

In step 2718, memory controller 2210 may be configured to open a secondmemory line in the first memory bank. For example, based on the tasksand using the pipelined memory access approach, memory controller 2210may be configured to open a second memory line to the first memoryblock. In some embodiments, the second memory line to the first blockmay be opened when the task in step 2176 is about to be completed.

In some embodiments, steps 2714-2718 may be executed within one lineaccess cycle.

In step 2720, memory controller 2210 may read or grant access to atleast one third word from the first memory bank from the plurality ofmemory banks or blocks using a second memory line in the first bank or afirst line in a third bank and continuing in different memory banks.

The foregoing description has been presented for purposes ofillustration. It is not exhaustive and is not limited to the preciseforms or embodiments disclosed. Modifications and adaptations will beapparent to those skilled in the art from consideration of thespecification and practice of the disclosed embodiments. Additionally,although aspects of the disclosed embodiments are described as beingstored in memory, one skilled in the art will appreciate that theseaspects can also be stored on other types of computer readable media,such as secondary storage devices, for example, hard disks or CD ROM, orother forms of RAM or ROM, USB media, DVD, Blu-ray, 4K Ultra HD Blu-ray,or other optical drive media.

Computer programs based on the written description and disclosed methodsare within the skill of an experienced developer. The various programsor program modules can be created using any of the techniques known toone skilled in the art or can be designed in connection with existingsoftware. For example, program sections or program modules can bedesigned in or by means of .Net Framework, .Net Compact Framework (andrelated languages, such as Visual Basic, C, etc.), Java, C++,Objective-C, HTML, HTML/AJAX combinations, XML, or HTML with includedJava applets.

Moreover, while illustrative embodiments have been described herein, thescope of any and all embodiments having equivalent elements,modifications, omissions, combinations (e.g., of aspects across variousembodiments), adaptations and/or alterations as would be appreciated bythose skilled in the art based on the present disclosure. Thelimitations in the claims are to be interpreted broadly based on thelanguage employed in the claims and not limited to examples described inthe present specification or during the prosecution of the application.The examples are to be construed as non-exclusive. Furthermore, thesteps of the disclosed methods may be modified in any manner, includingby reordering steps and/or inserting or deleting steps. It is intended,therefore, that the specification and examples be considered asillustrative only, with a true scope and spirit being indicated by thefollowing claims and their full scope of equivalents.

What is claimed is:
 1. A distributed processor on a memory chip,comprising: a semiconductor substrate; a plurality of processor subunitsdisposed on the semiconductor substrate, each processor subunit beingconfigured to execute a series of instructions independent from otherprocessor subunits, each series of instructions defining a series oftasks to be performed by a single processor subunit; a correspondingplurality of memory banks disposed on the semiconductor substrate, eachone of the plurality of processor subunits being connected to at leastone dedicated memory bank not shared by any others of the plurality ofprocessor subunits; and a plurality of buses, each of the plurality ofbuses connecting one of the plurality of processor subunits to at leastone other of the plurality of processor subunits, wherein data transfersacross at least one of the plurality of buses are predefined by theseries of instructions included in a processor subunit connected to theat least one of the plurality of buses; and wherein each of theplurality of processor subunits is configured to access data stored inat least its corresponding dedicated one of the plurality of memorybanks and perform one or more calculations using at least one valueincluded in the accessed data.
 2. The distributed processor on a memorychip of claim 1, wherein each series of instructions comprises a set ofmachine code defining a corresponding series of tasks.
 3. Thedistributed processor on a memory chip of claim 2, wherein the series oftasks are defined by a compiler configured to distribute a higher-levelseries of tasks amongst the plurality of logic circuits as a pluralityof series of tasks.
 4. The distributed processor on a memory chip ofclaim 3, wherein the higher-level series of tasks comprises a set ofinstructions in a human-readable programming language.
 5. Thedistributed processor on a memory chip of claim 1, wherein the series ofinstructions included in the processor subunit connected to the at leastone of the plurality of buses includes a sending task that comprises acommand for the processor subunit connected to the at least one of theplurality of buses to write data to the at least one of the plurality ofbuses.
 6. The distributed processor on a memory chip of claim 1, whereinthe series of instructions included in the processor subunit connectedto the at least one of the plurality of buses includes a receiving taskthat comprises a command for the processor subunit connected to the atleast one of the plurality of buses to read data from the at least oneof the plurality of buses.
 7. A distributed processor on a memory chip,comprising: a semiconductor substrate; a plurality of processor subunitsdisposed on the semiconductor substrate of the memory chip; a pluralityof memory banks disposed on the semiconductor substrate of the memorychip, wherein each one of the plurality of memory banks is configured tostore data independent from data stored in other ones of the pluralityof memory banks, and wherein each one of the plurality of processorsubunits is connected to at least one dedicated memory bank from amongthe plurality of memory banks; and a plurality of buses, wherein eachone of the plurality of buses connects one of the plurality of processorsubunits to one or more corresponding, dedicated memory banks from amongthe plurality of memory banks, wherein data transfers across aparticular one of the plurality of buses are controlled by acorresponding processor subunit connected to the particular one of theplurality of buses; and wherein each of the plurality of processorsubunits is configured to access data stored in at least itscorresponding dedicated one of the plurality of memory banks and performone or more calculations using at least one value included in theaccessed data.
 8. The distributed processor on a memory chip of claim 7,wherein the data stored in each of the plurality of memory banks aredefined by a compiler configured to distribute data amongst theplurality of memory banks.
 9. The distributed processor on a memory chipof claim 8, wherein the compiler is configured to distribute datadefined in a higher-level series of tasks amongst the plurality ofmemory banks using a plurality of lower-level tasks distributed amongstcorresponding processor subunits.
 10. The distributed processor on amemory chip of claim 9, wherein the higher-level series of taskscomprises a set of instructions in a human-readable programminglanguage.
 11. The distributed processor on a memory chip of claim 9,wherein the lower-level series of tasks comprises a set of instructionsin a machine code.
 12. A distributed processor on a memory chip,comprising: a semiconductor substrate; a plurality of processor subunitsdisposed on the semiconductor substrate of the memory chip; a pluralityof memory banks disposed on the semiconductor substrate of the memorychip, wherein each one of the plurality of processor subunits isconnected to at least one dedicated memory bank from among the pluralityof memory banks, and wherein each memory bank of the plurality of memorybanks is configured to store data independent from data stored in otherones of the plurality of memory banks, and wherein at least some of thedata stored in one particular memory bank from among the plurality ofmemory banks comprises a duplicate of data stored in at least anotherone of the plurality of memory banks; and a plurality of buses, whereineach one of the plurality of buses connects one of the plurality ofprocessor subunits to one or more corresponding, dedicated memory banksfrom among the plurality of memory banks, wherein data transfers acrossa particular one of the plurality of buses are controlled by acorresponding processor subunit connected to the particular one of theplurality of buses; and wherein each of the plurality of processorsubunits is configured to access data stored in at least itscorresponding dedicated one of the plurality of memory banks and performone or more calculations using at least one value included in theaccessed data.
 13. The distributed processor on a memory chip of claim12, wherein the at least some data duplicated across the one particularmemory bank from among the plurality of memory banks and the at leastanother one of the plurality of memory banks is defined by a compilerconfigured to duplicate data across memory banks.
 14. The distributedprocessor on a memory chip of claim 12, wherein the at least some dataduplicated across the one particular memory bank from among theplurality of memory banks and the at least another one of the pluralityof memory banks comprises weights of a neural network.
 15. Thedistributed processor on a memory chip of claim 14, wherein each node inthe neural network is defined by at least one processor subunit fromamong the plurality of processor subunits.
 16. The distributed processoron a memory chip of claim 15, wherein each node comprises machine codeexecuted by the at least one processor subunit defining the node.